
"""simple docstring"""


import json
import os
from typing import List, Optional, Tuple

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


__A		     =    logging.get_logger(__name__)

__A		     =    {
    "vocab_file": "vocab.json",
    "merges_file": "merges.txt",
}

__A		     =    {
    "vocab_file": {
        "microsoft/biogpt": "https://huggingface.co/microsoft/biogpt/resolve/main/vocab.json",
    },
    "merges_file": {"microsoft/biogpt": "https://huggingface.co/microsoft/biogpt/resolve/main/merges.txt"},
}

__A		     =    {
    "microsoft/biogpt": 1024,
}






def 					a__					(					__SCREAMING_SNAKE_CASE				)			->			Optional[int]:
		__lowerCAmelCase: List[Any]					   =    set()
		__lowerCAmelCase: Optional[int]					   =    word[0]
		for char in word[1:]:
				pairs.add((prev_char, char)				)
				__lowerCAmelCase: List[str]					   =    char
		return pairs





class 					snake_case			(       __snake_case						):
				SCREAMING_SNAKE_CASE_     :   List[Any]        =						VOCAB_FILES_NAMES
				SCREAMING_SNAKE_CASE_     :   List[str]        =						PRETRAINED_VOCAB_FILES_MAP
				SCREAMING_SNAKE_CASE_     :   Optional[int]        =						PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				SCREAMING_SNAKE_CASE_     :   Tuple        =						["""input_ids""", """attention_mask"""]

				def __init__(			self							:       Dict  ,						UpperCamelCase__							:       Union[str, Any]  ,						UpperCamelCase__							:       List[str]  ,						UpperCamelCase__							:       Tuple="<unk>"  ,						UpperCamelCase__							:       Optional[Any]="<s>"  ,						UpperCamelCase__							:       int="</s>"  ,						UpperCamelCase__							:       Dict="</s>"  ,						UpperCamelCase__							:       str="<pad>"  ,						**UpperCamelCase__							:       int  ,						)->     int:



						'''simple docstring'''


						super().__init__(
						    bos_token=UpperCamelCase__  ,						eos_token=UpperCamelCase__  ,						sep_token=UpperCamelCase__  ,						unk_token=UpperCamelCase__  ,						pad_token=UpperCamelCase__  ,						**UpperCamelCase__  ,						)

						try:
								import sacremoses
						except ImportError:
								raise ImportError(
								    "You need to install sacremoses to use BioGptTokenizer. "
								    "See https://pypi.org/project/sacremoses/ for installation.")

						__lowerCAmelCase: Optional[int]					   =    "en"
						__lowerCAmelCase: Tuple					   =    sacremoses
						# cache of sm.MosesTokenizer instance
						__lowerCAmelCase: Optional[Any]					   =    {}
						__lowerCAmelCase: Any					   =    {}
						with open(UpperCamelCase__  ,						encoding="utf-8") as vocab_handle:
								__lowerCAmelCase: Optional[Any]					   =    json.load(UpperCamelCase__)
						__lowerCAmelCase: List[str]					   =    {v: k for k, v in self.encoder.items()}
						with open(UpperCamelCase__  ,						encoding="utf-8") as merges_handle:
								__lowerCAmelCase: Optional[Any]					   =    merges_handle.read().split("\n")[:-1]
						__lowerCAmelCase: List[str]					   =    [tuple(merge.split()[:2]) for merge in merges]
						__lowerCAmelCase: Tuple					   =    dict(zip(UpperCamelCase__  ,						range(len(UpperCamelCase__))))
						__lowerCAmelCase: Dict					   =    {}

				@property
				def 							lowercase_  (			self							:       Any)->     Any:



						'''simple docstring'''


						return len(self.encoder)

				def 							lowercase_  (			self							:       Optional[int])->     Any:



						'''simple docstring'''


						return dict(self.encoder  ,						**self.added_tokens_encoder)

				def 							lowercase_  (			self							:       int  ,						UpperCamelCase__							:       Dict  ,						UpperCamelCase__							:       Union[str, Any])->     Optional[int]:



						'''simple docstring'''


						if lang not in self.cache_moses_tokenizer:
								__lowerCAmelCase: Any					   =    self.sm.MosesTokenizer(lang=UpperCamelCase__)
								__lowerCAmelCase: List[Any]					   =    moses_tokenizer
						return self.cache_moses_tokenizer[lang].tokenize(
						    UpperCamelCase__  ,						aggressive_dash_splits=UpperCamelCase__  ,						return_str=UpperCamelCase__  ,						escape=UpperCamelCase__)

				def 							lowercase_  (			self							:       List[Any]  ,						UpperCamelCase__							:       Any  ,						UpperCamelCase__							:       Dict)->     Any:



						'''simple docstring'''


						if lang not in self.cache_moses_detokenizer:
								__lowerCAmelCase: Union[str, Any]					   =    self.sm.MosesDetokenizer(lang=UpperCamelCase__)
								__lowerCAmelCase: str					   =    moses_detokenizer
						return self.cache_moses_detokenizer[lang].detokenize(UpperCamelCase__)

				def 							lowercase_  (			self							:       List[str]  ,						UpperCamelCase__							:       Optional[int])->     List[str]:



						'''simple docstring'''


						__lowerCAmelCase: Optional[int]					   =    tuple(token[:-1]) + (token[-1] + "</w>",)
						if token in self.cache:
								return self.cache[token]
						__lowerCAmelCase: Optional[int]					   =    get_pairs(UpperCamelCase__)

						if not pairs:
								return token + "</w>"

						while True:
								__lowerCAmelCase: List[str]					   =    min(UpperCamelCase__  ,						key=lambda UpperCamelCase__: self.bpe_ranks.get(UpperCamelCase__  ,						float("inf")))
								if bigram not in self.bpe_ranks:
										break
								__lowerCAmelCase: List[str]					   =    bigram
								__lowerCAmelCase: int					   =    []
								__lowerCAmelCase: List[str]					   =    0
								while i < len(UpperCamelCase__):
										try:
												__lowerCAmelCase: Tuple					   =    word.index(UpperCamelCase__  ,						UpperCamelCase__)
										except ValueError:
												new_word.extend(word[i:])
												break
										else:
												new_word.extend(word[i:j])
												__lowerCAmelCase: str					   =    j

										if word[i] == first and i < len(UpperCamelCase__) - 1 and word[i + 1] == second:
												new_word.append(first + second)
												i += 2
										else:
												new_word.append(word[i])
												i += 1
								__lowerCAmelCase: Dict					   =    tuple(UpperCamelCase__)
								__lowerCAmelCase: Union[str, Any]					   =    new_word
								if len(UpperCamelCase__) == 1:
										break
								else:
										__lowerCAmelCase: Any					   =    get_pairs(UpperCamelCase__)
						__lowerCAmelCase: Optional[int]					   =    " ".join(UpperCamelCase__)
						if word == "\n  </w>":
								__lowerCAmelCase: Optional[Any]					   =    "\n</w>"
						__lowerCAmelCase: Dict					   =    word
						return word

				def 							lowercase_  (			self							:       Optional[Any]  ,						UpperCamelCase__							:       Optional[int]  ,						UpperCamelCase__							:       int=False)->     Optional[int]:



						'''simple docstring'''


						if bypass_tokenizer:
								__lowerCAmelCase: Optional[Any]					   =    text.split()
						else:
								__lowerCAmelCase: str					   =    self.moses_tokenize(UpperCamelCase__  ,						self.lang)

						__lowerCAmelCase: Tuple					   =    []
						for token in text:
								if token:
										split_tokens.extend(list(self.bpe(UpperCamelCase__).split(" ")))

						return split_tokens

				def 							lowercase_  (			self							:       Dict  ,						UpperCamelCase__							:       Union[str, Any])->     Optional[Any]:



						'''simple docstring'''


						return self.encoder.get(UpperCamelCase__  ,						self.encoder.get(self.unk_token))

				def 							lowercase_  (			self							:       Optional[int]  ,						UpperCamelCase__							:       Optional[Any])->     Any:



						'''simple docstring'''


						return self.decoder.get(UpperCamelCase__  ,						self.unk_token)

				def 							lowercase_  (			self							:       str  ,						UpperCamelCase__							:       Dict)->     List[str]:



						'''simple docstring'''


						__lowerCAmelCase: Dict					   =    [t.replace(" "  ,						"").replace("</w>"  ,						" ") for t in tokens]
						__lowerCAmelCase: str					   =    "".join(UpperCamelCase__).split()
						# detokenize
						__lowerCAmelCase: Dict					   =    self.moses_detokenize(UpperCamelCase__  ,						self.lang)
						return text

				def 							lowercase_  (			self							:       Tuple  ,						UpperCamelCase__							:       List[int]  ,						UpperCamelCase__							:       Optional[List[int]] = None)->     List[int]:



						'''simple docstring'''


						if token_ids_a is None:
								return [self.sep_token_id] + token_ids_a
						__lowerCAmelCase: Tuple					   =    [self.sep_token_id]
						return sep + token_ids_a + sep + token_ids_a

				def 							lowercase_  (			self							:       Union[str, Any]  ,						UpperCamelCase__							:       List[int]  ,						UpperCamelCase__							:       Optional[List[int]] = None  ,						UpperCamelCase__							:       bool = False)->     List[int]:



						'''simple docstring'''


						if already_has_special_tokens:
								return super().get_special_tokens_mask(
								    token_ids_a=UpperCamelCase__  ,						token_ids_a=UpperCamelCase__  ,						already_has_special_tokens=UpperCamelCase__)
						# no bos used in fairseq
						if token_ids_a is not None:
								return [1] + ([0] * len(UpperCamelCase__)) + [1] + ([0] * len(UpperCamelCase__))
						return [1] + ([0] * len(UpperCamelCase__))

				def 							lowercase_  (			self							:       Any  ,						UpperCamelCase__							:       List[int]  ,						UpperCamelCase__							:       Optional[List[int]] = None)->     List[int]:



						'''simple docstring'''


						__lowerCAmelCase: int					   =    [self.sep_token_id]

						# no bos used in fairseq
						if token_ids_a is None:
								return len(token_ids_a + sep) * [0]
						return len(token_ids_a + sep) * [0] + len(token_ids_a + sep) * [1]

				def 							lowercase_  (			self							:       Union[str, Any]  ,						UpperCamelCase__							:       str  ,						UpperCamelCase__							:       Optional[str] = None)->     Tuple[str]:



						'''simple docstring'''


						if not os.path.isdir(UpperCamelCase__):
								logger.error(f"Vocabulary path ({save_directory}) should be a directory")
								return
						__lowerCAmelCase: int					   =    os.path.join(
						    UpperCamelCase__  ,						(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"])
						__lowerCAmelCase: str					   =    os.path.join(
						    UpperCamelCase__  ,						(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["merges_file"])

						with open(UpperCamelCase__  ,						"w"  ,						encoding="utf-8") as f:
								f.write(json.dumps(self.encoder  ,						indent=2  ,						sort_keys=UpperCamelCase__  ,						ensure_ascii=UpperCamelCase__) + "\n")

						__lowerCAmelCase: List[str]					   =    0
						with open(UpperCamelCase__  ,						"w"  ,						encoding="utf-8") as writer:
								for bpe_tokens, token_index in sorted(self.bpe_ranks.items()  ,						key=lambda UpperCamelCase__: kv[1]):
										if index != token_index:
												logger.warning(
												    f"Saving vocabulary to {merge_file}: BPE merge indices are not consecutive."
												    " Please check that the tokenizer is not corrupted!")
												__lowerCAmelCase: Tuple					   =    token_index
										writer.write(" ".join(UpperCamelCase__) + "\n")
										index += 1

						return vocab_file, merge_file

				def __getstate__(			self							:       str)->     Tuple:



						'''simple docstring'''


						__lowerCAmelCase: Dict					   =    self.__dict__.copy()
						__lowerCAmelCase: Tuple					   =    None
						return state




				def __setstate__(			self							:       Any  ,						UpperCamelCase__							:       List[str])->     Dict:



						'''simple docstring'''


						__lowerCAmelCase: Optional[int]					   =    d

						try:
								import sacremoses
						except ImportError:
								raise ImportError(
								    "You need to install sacremoses to use XLMTokenizer. "
								    "See https://pypi.org/project/sacremoses/ for installation.")

						__lowerCAmelCase: int					   =    sacremoses





"""simple docstring"""


from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    get_resize_output_image_size,
    normalize,
    pad,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    get_image_size,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging
from ...utils.import_utils import is_vision_available


__A		     =    logging.get_logger(__name__)


if is_vision_available():
			import PIL





class 					snake_case			(       __snake_case						):
				SCREAMING_SNAKE_CASE_     :   Union[str, Any]        =						["""pixel_values"""]

				def __init__(			self							:       int  ,						UpperCamelCase__							:       bool = True  ,						UpperCamelCase__							:       Dict[str, int] = None  ,						UpperCamelCase__							:       PILImageResampling = PILImageResampling.BILINEAR  ,						UpperCamelCase__							:       bool = True  ,						UpperCamelCase__							:       bool = False  ,						UpperCamelCase__							:       bool = True  ,						UpperCamelCase__							:       bool = True  ,						UpperCamelCase__							:       Union[int, float] = 1 / 2_5_5  ,						UpperCamelCase__							:       bool = True  ,						UpperCamelCase__							:       Optional[Union[float, List[float]]] = None  ,						UpperCamelCase__							:       Optional[Union[float, List[float]]] = None  ,						**UpperCamelCase__							:       Tuple  ,						)->     None:



						'''simple docstring'''


						super().__init__(**UpperCamelCase__)

						__lowerCAmelCase: List[str]					   =    size if size is not None else {"height": 2_5_6_0, "width": 1_9_2_0}
						if isinstance(UpperCamelCase__  ,						(tuple, list)):
								# The previous feature extractor size parameter was in (width, height) format
								__lowerCAmelCase: str					   =    size[::-1]
						__lowerCAmelCase: int					   =    get_size_dict(UpperCamelCase__)

						__lowerCAmelCase: Union[str, Any]					   =    do_resize
						__lowerCAmelCase: Optional[Any]					   =    size
						__lowerCAmelCase: List[str]					   =    resample
						__lowerCAmelCase: Tuple					   =    do_thumbnail
						__lowerCAmelCase: int					   =    do_align_long_axis
						__lowerCAmelCase: Any					   =    do_pad
						__lowerCAmelCase: Any					   =    do_rescale
						__lowerCAmelCase: int					   =    rescale_factor
						__lowerCAmelCase: str					   =    do_normalize
						__lowerCAmelCase: List[str]					   =    image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
						__lowerCAmelCase: List[Any]					   =    image_std if image_std is not None else IMAGENET_STANDARD_STD

				def 							lowercase_  (			self							:       Optional[int]  ,						UpperCamelCase__							:       np.ndarray  ,						UpperCamelCase__							:       Dict[str, int]  ,						UpperCamelCase__							:       Optional[Union[str, ChannelDimension]] = None)->     np.ndarray:



						'''simple docstring'''


						__lowerCAmelCase   ,				__lowerCAmelCase: Optional[int]					   =    get_image_size(UpperCamelCase__)
						__lowerCAmelCase   ,				__lowerCAmelCase: Union[str, Any]					   =    size["height"], size["width"]

						if (output_width < output_height and input_width > input_height) or (
						    output_width > output_height and input_width < input_height
						):
								__lowerCAmelCase: List[Any]					   =    np.rotaa(UpperCamelCase__  ,						3)

						if data_format is not None:
								__lowerCAmelCase: Dict					   =    to_channel_dimension_format(UpperCamelCase__  ,						UpperCamelCase__)

						return image

				def 							lowercase_  (			self							:       Optional[Any]  ,						UpperCamelCase__							:       np.ndarray  ,						UpperCamelCase__							:       Dict[str, int]  ,						UpperCamelCase__							:       bool = False  ,						UpperCamelCase__							:       Optional[Union[str, ChannelDimension]] = None  ,						)->     np.ndarray:



						'''simple docstring'''


						__lowerCAmelCase   ,				__lowerCAmelCase: List[str]					   =    size["height"], size["width"]
						__lowerCAmelCase   ,				__lowerCAmelCase: Optional[Any]					   =    get_image_size(UpperCamelCase__)

						__lowerCAmelCase: List[Any]					   =    output_width - input_width
						__lowerCAmelCase: str					   =    output_height - input_height

						if random_padding:
								__lowerCAmelCase: Tuple					   =    np.random.randint(low=0  ,						high=delta_height + 1)
								__lowerCAmelCase: Union[str, Any]					   =    np.random.randint(low=0  ,						high=delta_width + 1)
						else:
								__lowerCAmelCase: str					   =    delta_height // 2
								__lowerCAmelCase: Optional[Any]					   =    delta_width // 2

						__lowerCAmelCase: List[Any]					   =    delta_height - pad_top
						__lowerCAmelCase: Dict					   =    delta_width - pad_left

						__lowerCAmelCase: Optional[Any]					   =    ((pad_top, pad_bottom), (pad_left, pad_right))
						return pad(UpperCamelCase__  ,						UpperCamelCase__  ,						data_format=UpperCamelCase__)

				def 							lowercase_  (			self							:       Union[str, Any]  ,						*UpperCamelCase__							:       str  ,						**UpperCamelCase__							:       Optional[int])->     Optional[int]:



						'''simple docstring'''


						logger.info("pad is deprecated and will be removed in version 4.27. Please use pad_image instead.")
						return self.pad_image(*UpperCamelCase__  ,						**UpperCamelCase__)

				def 							lowercase_  (			self							:       List[str]  ,						UpperCamelCase__							:       np.ndarray  ,						UpperCamelCase__							:       Dict[str, int]  ,						UpperCamelCase__							:       PILImageResampling = PILImageResampling.BICUBIC  ,						UpperCamelCase__							:       Optional[Union[str, ChannelDimension]] = None  ,						**UpperCamelCase__							:       Optional[int]  ,						)->     np.ndarray:



						'''simple docstring'''


						__lowerCAmelCase   ,				__lowerCAmelCase: List[str]					   =    get_image_size(UpperCamelCase__)
						__lowerCAmelCase   ,				__lowerCAmelCase: Tuple					   =    size["height"], size["width"]

						# We always resize to the smallest of either the input or output size.
						__lowerCAmelCase: Union[str, Any]					   =    min(UpperCamelCase__  ,						UpperCamelCase__)
						__lowerCAmelCase: List[Any]					   =    min(UpperCamelCase__  ,						UpperCamelCase__)

						if height == input_height and width == input_width:
								return image

						if input_height > input_width:
								__lowerCAmelCase: Dict					   =    int(input_width * height / input_height)
						elif input_width > input_height:
								__lowerCAmelCase: Any					   =    int(input_height * width / input_width)

						return resize(
						    UpperCamelCase__  ,						size=(height, width)  ,						resample=UpperCamelCase__  ,						reducing_gap=2.0  ,						data_format=UpperCamelCase__  ,						**UpperCamelCase__)

				def 							lowercase_  (			self							:       int  ,						UpperCamelCase__							:       np.ndarray  ,						UpperCamelCase__							:       Dict[str, int]  ,						UpperCamelCase__							:       PILImageResampling = PILImageResampling.BICUBIC  ,						UpperCamelCase__							:       Optional[Union[str, ChannelDimension]] = None  ,						**UpperCamelCase__							:       Union[str, Any]  ,						)->     np.ndarray:



						'''simple docstring'''


						__lowerCAmelCase: Tuple					   =    get_size_dict(UpperCamelCase__)
						__lowerCAmelCase: Dict					   =    min(size["height"]  ,						size["width"])
						__lowerCAmelCase: List[str]					   =    get_resize_output_image_size(UpperCamelCase__  ,						size=UpperCamelCase__  ,						default_to_square=UpperCamelCase__)
						__lowerCAmelCase: Optional[int]					   =    resize(UpperCamelCase__  ,						size=UpperCamelCase__  ,						resample=UpperCamelCase__  ,						data_format=UpperCamelCase__  ,						**UpperCamelCase__)
						return resized_image

				def 							lowercase_  (			self							:       Optional[Any]  ,						UpperCamelCase__							:       np.ndarray  ,						UpperCamelCase__							:       Union[int, float]  ,						UpperCamelCase__							:       Optional[Union[str, ChannelDimension]] = None  ,						**UpperCamelCase__							:       Dict  ,						)->     int:



						'''simple docstring'''


						return rescale(UpperCamelCase__  ,						scale=UpperCamelCase__  ,						data_format=UpperCamelCase__  ,						**UpperCamelCase__)

				def 							lowercase_  (			self							:       Any  ,						UpperCamelCase__							:       np.ndarray  ,						UpperCamelCase__							:       Union[float, List[float]]  ,						UpperCamelCase__							:       Union[float, List[float]]  ,						UpperCamelCase__							:       Optional[Union[str, ChannelDimension]] = None  ,						**UpperCamelCase__							:       List[str]  ,						)->     np.ndarray:



						'''simple docstring'''


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




				def 							lowercase_  (			self							:       str  ,						UpperCamelCase__							:       ImageInput  ,						UpperCamelCase__							:       bool = None  ,						UpperCamelCase__							:       Dict[str, int] = None  ,						UpperCamelCase__							:       PILImageResampling = None  ,						UpperCamelCase__							:       bool = None  ,						UpperCamelCase__							:       bool = None  ,						UpperCamelCase__							:       bool = None  ,						UpperCamelCase__							:       bool = False  ,						UpperCamelCase__							:       bool = None  ,						UpperCamelCase__							:       float = None  ,						UpperCamelCase__							:       bool = None  ,						UpperCamelCase__							:       Optional[Union[float, List[float]]] = None  ,						UpperCamelCase__							:       Optional[Union[float, List[float]]] = None  ,						UpperCamelCase__							:       Optional[Union[str, TensorType]] = None  ,						UpperCamelCase__							:       Optional[ChannelDimension] = ChannelDimension.FIRST  ,						**UpperCamelCase__							:       Optional[Any]  ,						)->     PIL.Image.Image:



						'''simple docstring'''


						__lowerCAmelCase: Optional[int]					   =    do_resize if do_resize is not None else self.do_resize
						__lowerCAmelCase: Any					   =    size if size is not None else self.size
						if isinstance(UpperCamelCase__  ,						(tuple, list)):
								# Previous feature extractor had size in (width, height) format
								__lowerCAmelCase: int					   =    size[::-1]
						__lowerCAmelCase: Dict					   =    get_size_dict(UpperCamelCase__)
						__lowerCAmelCase: Optional[Any]					   =    resample if resample is not None else self.resample
						__lowerCAmelCase: int					   =    do_thumbnail if do_thumbnail is not None else self.do_thumbnail
						__lowerCAmelCase: Any					   =    do_align_long_axis if do_align_long_axis is not None else self.do_align_long_axis
						__lowerCAmelCase: str					   =    do_pad if do_pad is not None else self.do_pad
						__lowerCAmelCase: List[Any]					   =    do_rescale if do_rescale is not None else self.do_rescale
						__lowerCAmelCase: List[Any]					   =    rescale_factor if rescale_factor is not None else self.rescale_factor
						__lowerCAmelCase: List[Any]					   =    do_normalize if do_normalize is not None else self.do_normalize
						__lowerCAmelCase: Union[str, Any]					   =    image_mean if image_mean is not None else self.image_mean
						__lowerCAmelCase: List[str]					   =    image_std if image_std is not None else self.image_std

						__lowerCAmelCase: Union[str, Any]					   =    make_list_of_images(UpperCamelCase__)

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

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

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

						if do_pad and size is None:
								raise ValueError("Size must be specified if do_pad 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.")

						# All transformations expect numpy arrays.
						__lowerCAmelCase: int					   =    [to_numpy_array(UpperCamelCase__) for image in images]

						if do_align_long_axis:
								__lowerCAmelCase: Any					   =    [self.align_long_axis(UpperCamelCase__  ,						size=UpperCamelCase__) for image in images]

						if do_resize:
								__lowerCAmelCase: Tuple					   =    [self.resize(image=UpperCamelCase__  ,						size=UpperCamelCase__  ,						resample=UpperCamelCase__) for image in images]

						if do_thumbnail:
								__lowerCAmelCase: List[Any]					   =    [self.thumbnail(image=UpperCamelCase__  ,						size=UpperCamelCase__) for image in images]

						if do_pad:
								__lowerCAmelCase: Tuple					   =    [self.pad_image(image=UpperCamelCase__  ,						size=UpperCamelCase__  ,						random_padding=UpperCamelCase__) for image in images]

						if do_rescale:
								__lowerCAmelCase: Optional[int]					   =    [self.rescale(image=UpperCamelCase__  ,						scale=UpperCamelCase__) for image in images]

						if do_normalize:
								__lowerCAmelCase: Tuple					   =    [self.normalize(image=UpperCamelCase__  ,						mean=UpperCamelCase__  ,						std=UpperCamelCase__) for image in images]

						__lowerCAmelCase: Union[str, Any]					   =    [to_channel_dimension_format(UpperCamelCase__  ,						UpperCamelCase__) for image in images]

						__lowerCAmelCase: Optional[Any]					   =    {"pixel_values": images}
						return BatchFeature(data=UpperCamelCase__  ,						tensor_type=UpperCamelCase__)


