

import io
import math
from typing import Dict, Optional, Union

import numpy as np
from huggingface_hub import hf_hub_download

from ...image_processing_utils import BaseImageProcessor, BatchFeature
from ...image_transforms import convert_to_rgb, normalize, to_channel_dimension_format, to_pil_image
from ...image_utils import (
    ChannelDimension,
    ImageInput,
    get_image_size,
    infer_channel_dimension_format,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_torch_available, is_vision_available, logging
from ...utils.import_utils import requires_backends


if is_vision_available():
				import textwrap

				from PIL import Image, ImageDraw, ImageFont

if is_torch_available():
				import torch

				from transformers.pytorch_utils import is_torch_greater_or_equal_than_1_11
else:
				_a:    Dict 							=			False


_a:    Union[str, Any] 							=			logging.get_logger(__name__)
_a:    Tuple 							=			"""ybelkada/fonts"""



def       __lowerCAmelCase      (						):
	if is_torch_available() and not is_torch_greater_or_equal_than_1_11:
		raise ImportError(
		    F"You are using torch=={torch.__version__}, but torch>=1.11.0 is required to use "
		    "Pix2StructImageProcessor. Please upgrade torch."    )



def       __lowerCAmelCase      (						A       ,     A       ,     A    ):
	requires_backends(A       ,     ["torch"]    )
	_check_torch_version()

	UpperCAmelCase_       				=			image_tensor.unsqueeze(0    )
	UpperCAmelCase_       				=			torch.nn.functional.unfold(A       ,     (patch_height, patch_width)       ,     stride=(patch_height, patch_width)    )
	UpperCAmelCase_       				=			patches.reshape(image_tensor.size(0    )       ,     image_tensor.size(1    )       ,     A       ,     A       ,     -1    )
	UpperCAmelCase_       				=			patches.permute(0       ,     4       ,     2       ,     3       ,     1    ).reshape(
	    image_tensor.size(2    ) // patch_height       ,     image_tensor.size(3    ) // patch_width       ,     image_tensor.size(1    ) * patch_height * patch_width       ,     )
	return patches.unsqueeze(0    )



def       __lowerCAmelCase      (						A       ,     A = 36       ,     A = "black"       ,     A = "white"       ,     A = 5       ,     A = 5       ,     A = 5       ,     A = 5       ,     A = None       ,     A = None       ,     ):
	requires_backends(A       ,     "vision"    )
	# Add new lines so that each line is no more than 80 characters.

	UpperCAmelCase_       				=			textwrap.TextWrapper(width=80    )
	UpperCAmelCase_       				=			wrapper.wrap(text=A    )
	UpperCAmelCase_       				=			"\n".join(A    )

	if font_bytes is not None and font_path is None:
		UpperCAmelCase_       				=			io.BytesIO(A    )
	elif font_path is not None:
		UpperCAmelCase_       				=			font_path
	else:
		UpperCAmelCase_       				=			hf_hub_download(A       ,     "Arial.TTF"    )
	UpperCAmelCase_       				=			ImageFont.truetype(A       ,     encoding="UTF-8"       ,     size=A    )

	# Use a temporary canvas to determine the width and height in pixels when
	# rendering the text.
	UpperCAmelCase_       				=			ImageDraw.Draw(Image.new("RGB"       ,     (1, 1)       ,     A    )    )
	UpperCAmelCase_				,   UpperCAmelCase_				,   UpperCAmelCase_				,   UpperCAmelCase_       				=			temp_draw.textbbox((0, 0)       ,     A       ,     A    )

	# Create the actual image with a bit of padding around the text.
	UpperCAmelCase_       				=			text_width + left_padding + right_padding
	UpperCAmelCase_       				=			text_height + top_padding + bottom_padding
	UpperCAmelCase_       				=			Image.new("RGB"       ,     (image_width, image_height)       ,     A    )
	UpperCAmelCase_       				=			ImageDraw.Draw(A    )
	draw.text(xy=(left_padding, top_padding)       ,     text=A       ,     fill=A       ,     font=A    )
	return image



def       __lowerCAmelCase      (						A       ,     A       ,     **A    ):
	requires_backends(A       ,     "vision"    )

	# Convert to PIL image if necessary
	UpperCAmelCase_       				=			to_pil_image(A    )

	UpperCAmelCase_       				=			render_text(A       ,     **A    )
	UpperCAmelCase_       				=			max(header_image.width       ,     image.width    )

	UpperCAmelCase_       				=			int(image.height * (new_width / image.width)    )
	UpperCAmelCase_       				=			int(header_image.height * (new_width / header_image.width)    )

	UpperCAmelCase_       				=			Image.new("RGB"       ,     (new_width, new_height + new_header_height)       ,     "white"    )
	new_image.paste(header_image.resize((new_width, new_header_height)    )       ,     (0, 0)    )
	new_image.paste(image.resize((new_width, new_height)    )       ,     (0, new_header_height)    )

	# Convert back to the original framework if necessary
	UpperCAmelCase_       				=			to_numpy_array(A    )

	if infer_channel_dimension_format(A    ) == ChannelDimension.LAST:
		UpperCAmelCase_       				=			to_channel_dimension_format(A       ,     ChannelDimension.LAST    )

	return new_image




class 						__UpperCamelCase    (					lowercase						):
	SCREAMING_SNAKE_CASE__    				=     ['flattened_patches']




	def __init__(		self	:						List[Any]		,	lowerCAmelCase	:						bool = True		,	lowerCAmelCase	:						bool = True		,	lowerCAmelCase	:						Dict[str, int] = None		,	lowerCAmelCase	:						int = 2_048		,	lowerCAmelCase	:						bool = False		,	**lowerCAmelCase	:						Union[str, Any]		,	):


		'''simple docstring'''







		super().__init__(**lowerCAmelCase							)
		UpperCAmelCase_       				=			patch_size if patch_size is not None else {"height": 16, "width": 16}
		UpperCAmelCase_       				=			do_normalize
		UpperCAmelCase_       				=			do_convert_rgb
		UpperCAmelCase_       				=			max_patches
		UpperCAmelCase_       				=			is_vqa




	def       __A					(		self	:						Optional[int]		,	lowerCAmelCase	:						np.ndarray		,	lowerCAmelCase	:						int		,	lowerCAmelCase	:						dict		,	**lowerCAmelCase	:						Optional[int]							):


		'''simple docstring'''







		requires_backends(self.extract_flattened_patches		,	"torch"							)
		_check_torch_version()

		# convert to torch
		UpperCAmelCase_       				=			to_channel_dimension_format(lowerCAmelCase		,	ChannelDimension.FIRST							)
		UpperCAmelCase_       				=			torch.from_numpy(lowerCAmelCase							)

		UpperCAmelCase_				,   UpperCAmelCase_       				=			patch_size["height"], patch_size["width"]
		UpperCAmelCase_				,   UpperCAmelCase_       				=			get_image_size(lowerCAmelCase							)

		# maximize scale s.t.
		UpperCAmelCase_       				=			math.sqrt(max_patches * (patch_height / image_height) * (patch_width / image_width)							)
		UpperCAmelCase_       				=			max(min(math.floor(scale * image_height / patch_height							)		,	lowerCAmelCase							)		,	1							)
		UpperCAmelCase_       				=			max(min(math.floor(scale * image_width / patch_width							)		,	lowerCAmelCase							)		,	1							)
		UpperCAmelCase_       				=			max(num_feasible_rows * patch_height		,	1							)
		UpperCAmelCase_       				=			max(num_feasible_cols * patch_width		,	1							)

		UpperCAmelCase_       				=			torch.nn.functional.interpolate(
		    image.unsqueeze(0							)		,	size=(resized_height, resized_width)		,	mode="bilinear"		,	align_corners=lowerCAmelCase		,	antialias=lowerCAmelCase		,	).squeeze(0							)

		# [1, rows, columns, patch_height * patch_width * image_channels]
		UpperCAmelCase_       				=			torch_extract_patches(lowerCAmelCase		,	lowerCAmelCase		,	lowerCAmelCase							)

		UpperCAmelCase_       				=			patches.shape
		UpperCAmelCase_       				=			patches_shape[1]
		UpperCAmelCase_       				=			patches_shape[2]
		UpperCAmelCase_       				=			patches_shape[3]

		# [rows * columns, patch_height * patch_width * image_channels]
		UpperCAmelCase_       				=			patches.reshape([rows * columns, depth]							)

		# [rows * columns, 1]
		UpperCAmelCase_       				=			torch.arange(lowerCAmelCase							).reshape([rows, 1]							).repeat(1		,	lowerCAmelCase							).reshape([rows * columns, 1]							)
		UpperCAmelCase_       				=			torch.arange(lowerCAmelCase							).reshape([1, columns]							).repeat(lowerCAmelCase		,	1							).reshape([rows * columns, 1]							)

		# Offset by 1 so the ids do not contain zeros, which represent padding.
		row_ids += 1
		col_ids += 1

		# Prepare additional patch features.
		# [rows * columns, 1]
		UpperCAmelCase_       				=			row_ids.to(torch.floataa							)
		UpperCAmelCase_       				=			col_ids.to(torch.floataa							)

		# [rows * columns, 2 + patch_height * patch_width * image_channels]
		UpperCAmelCase_       				=			torch.cat([row_ids, col_ids, patches]		,	-1							)

		# [max_patches, 2 + patch_height * patch_width * image_channels]
		UpperCAmelCase_       				=			torch.nn.functional.pad(lowerCAmelCase		,	[0, 0, 0, max_patches - (rows * columns)]							).float()

		UpperCAmelCase_       				=			to_numpy_array(lowerCAmelCase							)

		return result




	def       __A					(		self	:						int		,	lowerCAmelCase	:						np.ndarray		,	lowerCAmelCase	:						Optional[Union[str, ChannelDimension]] = None		,	**lowerCAmelCase	:						Union[str, Any]							):


		'''simple docstring'''







		if image.dtype == np.uinta:
			UpperCAmelCase_       				=			image.astype(np.floataa							)

		# take mean across the whole `image`
		UpperCAmelCase_       				=			np.mean(lowerCAmelCase							)
		UpperCAmelCase_       				=			np.std(lowerCAmelCase							)
		UpperCAmelCase_       				=			max(lowerCAmelCase		,	1.0 / math.sqrt(np.prod(image.shape							)							)							)

		return normalize(lowerCAmelCase		,	mean=lowerCAmelCase		,	std=lowerCAmelCase		,	**lowerCAmelCase							)




	def       __A					(		self	:						Optional[int]		,	lowerCAmelCase	:						ImageInput		,	lowerCAmelCase	:						Optional[str] = None		,	lowerCAmelCase	:						bool = None		,	lowerCAmelCase	:						Optional[bool] = None		,	lowerCAmelCase	:						Optional[int] = None		,	lowerCAmelCase	:						Optional[Dict[str, int]] = None		,	lowerCAmelCase	:						Optional[Union[str, TensorType]] = None		,	lowerCAmelCase	:						ChannelDimension = ChannelDimension.FIRST		,	**lowerCAmelCase	:						str		,	):


		'''simple docstring'''







		UpperCAmelCase_       				=			do_normalize if do_normalize is not None else self.do_normalize
		UpperCAmelCase_       				=			do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb
		UpperCAmelCase_       				=			patch_size if patch_size is not None else self.patch_size
		UpperCAmelCase_       				=			max_patches if max_patches is not None else self.max_patches
		UpperCAmelCase_       				=			self.is_vqa

		if kwargs.get("data_format"		,	lowerCAmelCase							) is not None:
			raise ValueError("data_format is not an accepted input as the outputs are "							)

		UpperCAmelCase_       				=			make_list_of_images(lowerCAmelCase							)

		if not valid_images(lowerCAmelCase							):
			raise ValueError(
			    "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
			    "torch.Tensor, tf.Tensor or jax.ndarray."							)

		# PIL RGBA images are converted to RGB
		if do_convert_rgb:
			UpperCAmelCase_       				=			[convert_to_rgb(lowerCAmelCase							) for image in images]

		# All transformations expect numpy arrays.
		UpperCAmelCase_       				=			[to_numpy_array(lowerCAmelCase							) for image in images]

		if is_vqa:
			if header_text is None:
				raise ValueError("A header text must be provided for VQA models."							)
			UpperCAmelCase_       				=			kwargs.pop("font_bytes"		,	lowerCAmelCase							)
			UpperCAmelCase_       				=			kwargs.pop("font_path"		,	lowerCAmelCase							)

			if isinstance(lowerCAmelCase		,	lowerCAmelCase							):
				UpperCAmelCase_       				=			[header_text] * len(lowerCAmelCase							)

			UpperCAmelCase_       				=			[
			    render_header(lowerCAmelCase		,	header_text[i]		,	font_bytes=lowerCAmelCase		,	font_path=lowerCAmelCase							)
			    for i, image in enumerate(lowerCAmelCase							)
			]

		if do_normalize:
			UpperCAmelCase_       				=			[self.normalize(image=lowerCAmelCase							) for image in images]

		# convert to torch tensor and permute
		UpperCAmelCase_       				=			[
		    self.extract_flattened_patches(image=lowerCAmelCase		,	max_patches=lowerCAmelCase		,	patch_size=lowerCAmelCase							)
		    for image in images
		]

		# create attention mask in numpy
		UpperCAmelCase_       				=			[(image.sum(axis=-1							) != 0).astype(np.floataa							) for image in images]

		UpperCAmelCase_       				=			BatchFeature(
		    data={"flattened_patches": images, "attention_mask": attention_masks}		,	tensor_type=lowerCAmelCase							)

		return encoded_outputs









from typing import Dict, List, Optional, Union

import numpy as np

from transformers.utils import is_vision_available
from transformers.utils.generic import TensorType

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    is_valid_image,
    to_numpy_array,
    valid_images,
)
from ...utils import logging


if is_vision_available():
				import PIL

_a:    Optional[Any] 							=			logging.get_logger(__name__)



def       __lowerCAmelCase      (						A    ):
	if isinstance(A       ,     (list, tuple)    ) and isinstance(videos[0]       ,     (list, tuple)    ) and is_valid_image(videos[0][0]    ):
		return videos

	elif isinstance(A       ,     (list, tuple)    ) and is_valid_image(videos[0]    ):
		return [videos]

	elif is_valid_image(A    ):
		return [[videos]]

	raise ValueError(F"Could not make batched video from {videos}"    )




class 						__UpperCamelCase    (					lowercase						):
	SCREAMING_SNAKE_CASE__    				=     ['pixel_values']




	def __init__(		self	:						int		,	lowerCAmelCase	:						bool = True		,	lowerCAmelCase	:						Dict[str, int] = None		,	lowerCAmelCase	:						PILImageResampling = PILImageResampling.BILINEAR		,	lowerCAmelCase	:						bool = True		,	lowerCAmelCase	:						Dict[str, int] = None		,	lowerCAmelCase	:						bool = True		,	lowerCAmelCase	:						Union[int, float] = 1 / 255		,	lowerCAmelCase	:						bool = True		,	lowerCAmelCase	:						bool = True		,	lowerCAmelCase	:						Optional[Union[float, List[float]]] = None		,	lowerCAmelCase	:						Optional[Union[float, List[float]]] = None		,	**lowerCAmelCase	:						List[Any]		,	):


		'''simple docstring'''







		super().__init__(**lowerCAmelCase							)
		UpperCAmelCase_       				=			size if size is not None else {"shortest_edge": 256}
		UpperCAmelCase_       				=			get_size_dict(lowerCAmelCase		,	default_to_square=lowerCAmelCase							)
		UpperCAmelCase_       				=			crop_size if crop_size is not None else {"height": 224, "width": 224}
		UpperCAmelCase_       				=			get_size_dict(lowerCAmelCase		,	param_name="crop_size"							)

		UpperCAmelCase_       				=			do_resize
		UpperCAmelCase_       				=			size
		UpperCAmelCase_       				=			do_center_crop
		UpperCAmelCase_       				=			crop_size
		UpperCAmelCase_       				=			resample
		UpperCAmelCase_       				=			do_rescale
		UpperCAmelCase_       				=			rescale_factor
		UpperCAmelCase_       				=			offset
		UpperCAmelCase_       				=			do_normalize
		UpperCAmelCase_       				=			image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
		UpperCAmelCase_       				=			image_std if image_std is not None else IMAGENET_STANDARD_STD




	def       __A					(		self	:						List[Any]		,	lowerCAmelCase	:						np.ndarray		,	lowerCAmelCase	:						Dict[str, int]		,	lowerCAmelCase	:						PILImageResampling = PILImageResampling.BILINEAR		,	lowerCAmelCase	:						Optional[Union[str, ChannelDimension]] = None		,	**lowerCAmelCase	:						List[str]		,	):


		'''simple docstring'''







		UpperCAmelCase_       				=			get_size_dict(lowerCAmelCase		,	default_to_square=lowerCAmelCase							)
		if "shortest_edge" in size:
			UpperCAmelCase_       				=			get_resize_output_image_size(lowerCAmelCase		,	size["shortest_edge"]		,	default_to_square=lowerCAmelCase							)
		elif "height" in size and "width" in size:
			UpperCAmelCase_       				=			(size["height"], size["width"])
		else:
			raise ValueError(F"Size must have 'height' and 'width' or 'shortest_edge' as keys. Got {size.keys()}"							)
		return resize(lowerCAmelCase		,	size=lowerCAmelCase		,	resample=lowerCAmelCase		,	data_format=lowerCAmelCase		,	**lowerCAmelCase							)




	def       __A					(		self	:						List[str]		,	lowerCAmelCase	:						np.ndarray		,	lowerCAmelCase	:						Dict[str, int]		,	lowerCAmelCase	:						Optional[Union[str, ChannelDimension]] = None		,	**lowerCAmelCase	:						Dict		,	):


		'''simple docstring'''







		UpperCAmelCase_       				=			get_size_dict(lowerCAmelCase							)
		if "height" not in size or "width" not in size:
			raise ValueError(F"Size must have 'height' and 'width' as keys. Got {size.keys()}"							)
		return center_crop(lowerCAmelCase		,	size=(size["height"], size["width"])		,	data_format=lowerCAmelCase		,	**lowerCAmelCase							)




	def       __A					(		self	:						List[Any]		,	lowerCAmelCase	:						np.ndarray		,	lowerCAmelCase	:						Union[int, float]		,	lowerCAmelCase	:						bool = True		,	lowerCAmelCase	:						Optional[Union[str, ChannelDimension]] = None		,	**lowerCAmelCase	:						List[str]		,	):


		'''simple docstring'''







		UpperCAmelCase_       				=			image.astype(np.floataa							)
		if offset:
			UpperCAmelCase_       				=			image - (scale / 2)
		return rescale(lowerCAmelCase		,	scale=lowerCAmelCase		,	data_format=lowerCAmelCase		,	**lowerCAmelCase							)




	def       __A					(		self	:						Tuple		,	lowerCAmelCase	:						np.ndarray		,	lowerCAmelCase	:						Union[float, List[float]]		,	lowerCAmelCase	:						Union[float, List[float]]		,	lowerCAmelCase	:						Optional[Union[str, ChannelDimension]] = None		,	**lowerCAmelCase	:						int		,	):


		'''simple docstring'''







		return normalize(lowerCAmelCase		,	mean=lowerCAmelCase		,	std=lowerCAmelCase		,	data_format=lowerCAmelCase		,	**lowerCAmelCase							)




	def       __A					(		self	:						Union[str, Any]		,	lowerCAmelCase	:						ImageInput		,	lowerCAmelCase	:						bool = None		,	lowerCAmelCase	:						Dict[str, int] = None		,	lowerCAmelCase	:						PILImageResampling = None		,	lowerCAmelCase	:						bool = None		,	lowerCAmelCase	:						Dict[str, int] = None		,	lowerCAmelCase	:						bool = None		,	lowerCAmelCase	:						float = None		,	lowerCAmelCase	:						bool = None		,	lowerCAmelCase	:						bool = None		,	lowerCAmelCase	:						Optional[Union[float, List[float]]] = None		,	lowerCAmelCase	:						Optional[Union[float, List[float]]] = None		,	lowerCAmelCase	:						Optional[ChannelDimension] = ChannelDimension.FIRST		,	):


		'''simple docstring'''







		if do_resize and size is None or resample is None:
			raise ValueError("Size and resample must be specified if do_resize is True."							)

		if do_center_crop and crop_size is None:
			raise ValueError("Crop size must be specified if do_center_crop is True."							)

		if do_rescale and rescale_factor is None:
			raise ValueError("Rescale factor must be specified if do_rescale is True."							)

		if do_normalize and (image_mean is None or image_std is None):
			raise ValueError("Image mean and std must be specified if do_normalize is True."							)

		if offset and not do_rescale:
			raise ValueError("For offset, do_rescale must also be set to True."							)

		# All transformations expect numpy arrays.
		UpperCAmelCase_       				=			to_numpy_array(lowerCAmelCase							)

		if do_resize:
			UpperCAmelCase_       				=			self.resize(image=lowerCAmelCase		,	size=lowerCAmelCase		,	resample=lowerCAmelCase							)

		if do_center_crop:
			UpperCAmelCase_       				=			self.center_crop(lowerCAmelCase		,	size=lowerCAmelCase							)

		if do_rescale:
			UpperCAmelCase_       				=			self.rescale(image=lowerCAmelCase		,	scale=lowerCAmelCase		,	offset=lowerCAmelCase							)

		if do_normalize:
			UpperCAmelCase_       				=			self.normalize(image=lowerCAmelCase		,	mean=lowerCAmelCase		,	std=lowerCAmelCase							)

		UpperCAmelCase_       				=			to_channel_dimension_format(lowerCAmelCase		,	lowerCAmelCase							)
		return image




	def       __A					(		self	:						Optional[int]		,	lowerCAmelCase	:						ImageInput		,	lowerCAmelCase	:						bool = None		,	lowerCAmelCase	:						Dict[str, int] = None		,	lowerCAmelCase	:						PILImageResampling = None		,	lowerCAmelCase	:						bool = None		,	lowerCAmelCase	:						Dict[str, int] = None		,	lowerCAmelCase	:						bool = None		,	lowerCAmelCase	:						float = None		,	lowerCAmelCase	:						bool = None		,	lowerCAmelCase	:						bool = None		,	lowerCAmelCase	:						Optional[Union[float, List[float]]] = None		,	lowerCAmelCase	:						Optional[Union[float, List[float]]] = None		,	lowerCAmelCase	:						Optional[Union[str, TensorType]] = None		,	lowerCAmelCase	:						ChannelDimension = ChannelDimension.FIRST		,	**lowerCAmelCase	:						Dict		,	):


		'''simple docstring'''







		UpperCAmelCase_       				=			do_resize if do_resize is not None else self.do_resize
		UpperCAmelCase_       				=			resample if resample is not None else self.resample
		UpperCAmelCase_       				=			do_center_crop if do_center_crop is not None else self.do_center_crop
		UpperCAmelCase_       				=			do_rescale if do_rescale is not None else self.do_rescale
		UpperCAmelCase_       				=			rescale_factor if rescale_factor is not None else self.rescale_factor
		UpperCAmelCase_       				=			offset if offset is not None else self.offset
		UpperCAmelCase_       				=			do_normalize if do_normalize is not None else self.do_normalize
		UpperCAmelCase_       				=			image_mean if image_mean is not None else self.image_mean
		UpperCAmelCase_       				=			image_std if image_std is not None else self.image_std

		UpperCAmelCase_       				=			size if size is not None else self.size
		UpperCAmelCase_       				=			get_size_dict(lowerCAmelCase		,	default_to_square=lowerCAmelCase							)
		UpperCAmelCase_       				=			crop_size if crop_size is not None else self.crop_size
		UpperCAmelCase_       				=			get_size_dict(lowerCAmelCase		,	param_name="crop_size"							)

		if not valid_images(lowerCAmelCase							):
			raise ValueError(
			    "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
			    "torch.Tensor, tf.Tensor or jax.ndarray."							)

		UpperCAmelCase_       				=			make_batched(lowerCAmelCase							)

		UpperCAmelCase_       				=			[
		    [
		        self._preprocess_image(
		            image=lowerCAmelCase		,	do_resize=lowerCAmelCase		,	size=lowerCAmelCase		,	resample=lowerCAmelCase		,	do_center_crop=lowerCAmelCase		,	crop_size=lowerCAmelCase		,	do_rescale=lowerCAmelCase		,	rescale_factor=lowerCAmelCase		,	offset=lowerCAmelCase		,	do_normalize=lowerCAmelCase		,	image_mean=lowerCAmelCase		,	image_std=lowerCAmelCase		,	data_format=lowerCAmelCase		,	)
		        for img in video
		    ]
		    for video in videos
		]

		UpperCAmelCase_       				=			{"pixel_values": videos}
		return BatchFeature(data=lowerCAmelCase		,	tensor_type=lowerCAmelCase							)