



"""simple docstring"""







import json
import os
import re
import unittest

from transformers import CodeGenTokenizer, CodeGenTokenizerFast
from transformers.models.codegen.tokenization_codegen import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin







@require_tokenizers
class 					A_(_lowerCAmelCase   ,   unittest.TestCase      ):







			"""simple docstring"""



			a_       :			Optional[int]												=			CodeGenTokenizer
			a_       :			str												=			CodeGenTokenizerFast
			a_       :			str												=			True
			a_       :			str												=			{"""add_prefix_space""": True}
			a_       :			Union[str, Any]												=			False
			def    _lowerCAmelCase		(	self							):
						super().setUp()

						# Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
						_lowerCamelCase					:					Any	       =    [
						    """l""",
						    """o""",
						    """w""",
						    """e""",
						    """r""",
						    """s""",
						    """t""",
						    """i""",
						    """d""",
						    """n""",
						    """\u0120""",
						    """\u0120l""",
						    """\u0120n""",
						    """\u0120lo""",
						    """\u0120low""",
						    """er""",
						    """\u0120lowest""",
						    """\u0120newer""",
						    """\u0120wider""",
						    """<unk>""",
						    """<|endoftext|>""",
						]
						_lowerCamelCase					:					str	       =    dict(zip(SCREAMING_SNAKE_CASE_				,   range(len(SCREAMING_SNAKE_CASE_							)							)							)							)
						_lowerCamelCase					:					str	       =    ["""#version: 0.2""", """\u0120 l""", """\u0120l o""", """\u0120lo w""", """e r""", """"""]
						_lowerCamelCase					:					Dict	       =    {"""unk_token""": """<unk>"""}

						_lowerCamelCase					:					int	       =    os.path.join(self.tmpdirname				,   VOCAB_FILES_NAMES['vocab_file']							)
						_lowerCamelCase					:					Any	       =    os.path.join(self.tmpdirname				,   VOCAB_FILES_NAMES['merges_file']							)
						with open(self.vocab_file				,   'w'				,   encoding='utf-8'							) as fp:
									fp.write(json.dumps(SCREAMING_SNAKE_CASE_							) + '\n'							)
						with open(self.merges_file				,   'w'				,   encoding='utf-8'							) as fp:
									fp.write('\n'.join(SCREAMING_SNAKE_CASE_							)							)
			def    _lowerCAmelCase		(	self				,   **A							):
						kwargs.update(self.special_tokens_map							)
						return CodeGenTokenizer.from_pretrained(self.tmpdirname				,   **SCREAMING_SNAKE_CASE_							)
			def    _lowerCAmelCase		(	self				,   **A							):
						kwargs.update(self.special_tokens_map							)
						return CodeGenTokenizerFast.from_pretrained(self.tmpdirname				,   **SCREAMING_SNAKE_CASE_							)
			def    _lowerCAmelCase		(	self				,   A							):
						_lowerCamelCase					:					Dict	       =    """lower newer"""
						_lowerCamelCase					:					int	       =    """lower newer"""
						return input_text, output_text
			def    _lowerCAmelCase		(	self							):
						_lowerCamelCase					:					Optional[Any]	       =    CodeGenTokenizer(self.vocab_file				,   self.merges_file				,   **self.special_tokens_map							)
						_lowerCamelCase					:					int	       =    """lower newer"""
						_lowerCamelCase					:					int	       =    ["""\u0120low""", """er""", """\u0120""", """n""", """e""", """w""", """er"""]
						_lowerCamelCase					:					Union[str, Any]	       =    tokenizer.tokenize(SCREAMING_SNAKE_CASE_				,   add_prefix_space=SCREAMING_SNAKE_CASE_							)
						self.assertListEqual(SCREAMING_SNAKE_CASE_				,   SCREAMING_SNAKE_CASE_							)

						_lowerCamelCase					:					List[str]	       =    tokens + [tokenizer.unk_token]
						_lowerCamelCase					:					str	       =    [14, 15, 10, 9, 3, 2, 15, 19]
						self.assertListEqual(tokenizer.convert_tokens_to_ids(SCREAMING_SNAKE_CASE_							)				,   SCREAMING_SNAKE_CASE_							)
			def    _lowerCAmelCase		(	self							):
						if not self.test_rust_tokenizer:
									return

						_lowerCamelCase					:					Dict	       =    self.get_tokenizer()
						_lowerCamelCase					:					Union[str, Any]	       =    self.get_rust_tokenizer(add_prefix_space=SCREAMING_SNAKE_CASE_							)

						_lowerCamelCase					:					Optional[Any]	       =    """lower newer"""

						# Testing tokenization
						_lowerCamelCase					:					List[Any]	       =    tokenizer.tokenize(SCREAMING_SNAKE_CASE_				,   add_prefix_space=SCREAMING_SNAKE_CASE_							)
						_lowerCamelCase					:					List[str]	       =    rust_tokenizer.tokenize(SCREAMING_SNAKE_CASE_							)
						self.assertListEqual(SCREAMING_SNAKE_CASE_				,   SCREAMING_SNAKE_CASE_							)

						# Testing conversion to ids without special tokens
						_lowerCamelCase					:					List[Any]	       =    tokenizer.encode(SCREAMING_SNAKE_CASE_				,   add_special_tokens=SCREAMING_SNAKE_CASE_				,   add_prefix_space=SCREAMING_SNAKE_CASE_							)
						_lowerCamelCase					:					int	       =    rust_tokenizer.encode(SCREAMING_SNAKE_CASE_				,   add_special_tokens=SCREAMING_SNAKE_CASE_							)
						self.assertListEqual(SCREAMING_SNAKE_CASE_				,   SCREAMING_SNAKE_CASE_							)

						# Testing conversion to ids with special tokens
						_lowerCamelCase					:					Union[str, Any]	       =    self.get_rust_tokenizer(add_prefix_space=SCREAMING_SNAKE_CASE_							)
						_lowerCamelCase					:					List[Any]	       =    tokenizer.encode(SCREAMING_SNAKE_CASE_				,   add_prefix_space=SCREAMING_SNAKE_CASE_							)
						_lowerCamelCase					:					str	       =    rust_tokenizer.encode(SCREAMING_SNAKE_CASE_							)
						self.assertListEqual(SCREAMING_SNAKE_CASE_				,   SCREAMING_SNAKE_CASE_							)

						# Testing the unknown token
						_lowerCamelCase					:					Dict	       =    tokens + [rust_tokenizer.unk_token]
						_lowerCamelCase					:					List[str]	       =    [14, 15, 10, 9, 3, 2, 15, 19]
						self.assertListEqual(rust_tokenizer.convert_tokens_to_ids(SCREAMING_SNAKE_CASE_							)				,   SCREAMING_SNAKE_CASE_							)
			def    _lowerCAmelCase		(	self				,   *A				,   **A							):
						# It's very difficult to mix/test pretokenization with byte-level
						# And get both CodeGen and Roberta to work at the same time (mostly an issue of adding a space before the string)
						pass
			def    _lowerCAmelCase		(	self				,   A=15							):
						for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
									with self.subTest(F"{tokenizer.__class__.__name__} ({pretrained_name})"							):
												_lowerCamelCase					:					Any	       =    self.rust_tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_				,   **SCREAMING_SNAKE_CASE_							)

												# Simple input
												_lowerCamelCase					:					List[Any]	       =    """This is a simple input"""
												_lowerCamelCase					:					Tuple	       =    ["""This is a simple input 1""", """This is a simple input 2"""]
												_lowerCamelCase					:					Any	       =    ("""This is a simple input""", """This is a pair""")
												_lowerCamelCase					:					str	       =    [
												    ("""This is a simple input 1""", """This is a simple input 2"""),
												    ("""This is a simple pair 1""", """This is a simple pair 2"""),
												]

												# Simple input tests
												self.assertRaises(SCREAMING_SNAKE_CASE_				,   tokenizer_r.encode				,   SCREAMING_SNAKE_CASE_				,   max_length=SCREAMING_SNAKE_CASE_				,   padding='max_length'							)

												# Simple input
												self.assertRaises(SCREAMING_SNAKE_CASE_				,   tokenizer_r.encode_plus				,   SCREAMING_SNAKE_CASE_				,   max_length=SCREAMING_SNAKE_CASE_				,   padding='max_length'							)

												# Simple input
												self.assertRaises(
												    SCREAMING_SNAKE_CASE_				,   tokenizer_r.batch_encode_plus				,   SCREAMING_SNAKE_CASE_				,   max_length=SCREAMING_SNAKE_CASE_				,   padding='max_length'				,   )

												# Pair input
												self.assertRaises(SCREAMING_SNAKE_CASE_				,   tokenizer_r.encode				,   SCREAMING_SNAKE_CASE_				,   max_length=SCREAMING_SNAKE_CASE_				,   padding='max_length'							)

												# Pair input
												self.assertRaises(SCREAMING_SNAKE_CASE_				,   tokenizer_r.encode_plus				,   SCREAMING_SNAKE_CASE_				,   max_length=SCREAMING_SNAKE_CASE_				,   padding='max_length'							)

												# Pair input
												self.assertRaises(
												    SCREAMING_SNAKE_CASE_				,   tokenizer_r.batch_encode_plus				,   SCREAMING_SNAKE_CASE_				,   max_length=SCREAMING_SNAKE_CASE_				,   padding='max_length'				,   )
			def    _lowerCAmelCase		(	self							):
						_lowerCamelCase					:					int	       =    CodeGenTokenizer.from_pretrained(self.tmpdirname				,   pad_token='<pad>'							)

						# Simple input
						_lowerCamelCase					:					Any	       =    """This is a simple input"""
						_lowerCamelCase					:					Tuple	       =    ["""This is a simple input looooooooong""", """This is a simple input"""]
						_lowerCamelCase					:					str	       =    ("""This is a simple input""", """This is a pair""")
						_lowerCamelCase					:					Optional[int]	       =    [
						    ("""This is a simple input loooooong""", """This is a simple input"""),
						    ("""This is a simple pair loooooong""", """This is a simple pair"""),
						]

						_lowerCamelCase					:					Dict	       =    tokenizer.pad_token_id

						_lowerCamelCase					:					Any	       =    tokenizer(SCREAMING_SNAKE_CASE_				,   padding='max_length'				,   max_length=30				,   return_tensors='np'							)
						_lowerCamelCase					:					List[str]	       =    tokenizer(SCREAMING_SNAKE_CASE_				,   padding=SCREAMING_SNAKE_CASE_				,   truncate=SCREAMING_SNAKE_CASE_				,   return_tensors='np'							)
						_lowerCamelCase					:					Optional[Any]	       =    tokenizer(*SCREAMING_SNAKE_CASE_				,   padding='max_length'				,   max_length=60				,   return_tensors='np'							)
						_lowerCamelCase					:					List[str]	       =    tokenizer(SCREAMING_SNAKE_CASE_				,   padding=SCREAMING_SNAKE_CASE_				,   truncate=SCREAMING_SNAKE_CASE_				,   return_tensors='np'							)

						# s
						# test single string max_length padding
						self.assertEqual(out_s['input_ids'].shape[-1]				,   30							)
						self.assertTrue(pad_token_id in out_s['input_ids']							)
						self.assertTrue(0 in out_s['attention_mask']							)

						# s2
						# test automatic padding
						self.assertEqual(out_sa['input_ids'].shape[-1]				,   33							)
						# long slice doesn't have padding
						self.assertFalse(pad_token_id in out_sa['input_ids'][0]							)
						self.assertFalse(0 in out_sa['attention_mask'][0]							)
						# short slice does have padding
						self.assertTrue(pad_token_id in out_sa['input_ids'][1]							)
						self.assertTrue(0 in out_sa['attention_mask'][1]							)

						# p
						# test single pair max_length padding
						self.assertEqual(out_p['input_ids'].shape[-1]				,   60							)
						self.assertTrue(pad_token_id in out_p['input_ids']							)
						self.assertTrue(0 in out_p['attention_mask']							)

						# p2
						# test automatic padding pair
						self.assertEqual(out_pa['input_ids'].shape[-1]				,   52							)
						# long slice pair doesn't have padding
						self.assertFalse(pad_token_id in out_pa['input_ids'][0]							)
						self.assertFalse(0 in out_pa['attention_mask'][0]							)
						# short slice pair does have padding
						self.assertTrue(pad_token_id in out_pa['input_ids'][1]							)
						self.assertTrue(0 in out_pa['attention_mask'][1]							)
			def    _lowerCAmelCase		(	self							):
						_lowerCamelCase					:					str	       =    """$$$"""
						_lowerCamelCase					:					str	       =    CodeGenTokenizer.from_pretrained(self.tmpdirname				,   bos_token=SCREAMING_SNAKE_CASE_				,   add_bos_token=SCREAMING_SNAKE_CASE_							)

						_lowerCamelCase					:					Optional[Any]	       =    """This is a simple input"""
						_lowerCamelCase					:					Optional[Any]	       =    ["""This is a simple input 1""", """This is a simple input 2"""]

						_lowerCamelCase					:					Union[str, Any]	       =    tokenizer.bos_token_id

						_lowerCamelCase					:					Union[str, Any]	       =    tokenizer(SCREAMING_SNAKE_CASE_							)
						_lowerCamelCase					:					List[str]	       =    tokenizer(SCREAMING_SNAKE_CASE_							)

						self.assertEqual(out_s.input_ids[0]				,   SCREAMING_SNAKE_CASE_							)
						self.assertTrue(all(o[0] == bos_token_id for o in out_sa.input_ids							)							)

						_lowerCamelCase					:					Union[str, Any]	       =    tokenizer.decode(out_s.input_ids							)
						_lowerCamelCase					:					Optional[int]	       =    tokenizer.batch_decode(out_sa.input_ids							)

						self.assertEqual(decode_s.split()[0]				,   SCREAMING_SNAKE_CASE_							)
						self.assertTrue(all(d.split()[0] == bos_token for d in decode_sa							)							)
			@slow
			def    _lowerCAmelCase		(	self							):
						_lowerCamelCase					:					Tuple	       =    CodeGenTokenizer.from_pretrained('Salesforce/codegen-350M-mono'							)

						_lowerCamelCase					:					int	       =    """\nif len_a > len_b:\n    result = a\nelse:\n    result = b\n\n\n\n#"""
						_lowerCamelCase					:					str	       =    """\nif len_a > len_b:      result = a\nelse:      result = b"""

						_lowerCamelCase					:					Union[str, Any]	       =    tokenizer.encode(SCREAMING_SNAKE_CASE_							)
						_lowerCamelCase					:					int	       =    ["""^#""", re.escape('<|endoftext|>'							), """^'''""", """^\"\"\"""", """\n\n\n"""]
						_lowerCamelCase					:					Optional[Any]	       =    tokenizer.decode(SCREAMING_SNAKE_CASE_				,   truncate_before_pattern=SCREAMING_SNAKE_CASE_							)
						self.assertEqual(SCREAMING_SNAKE_CASE_				,   SCREAMING_SNAKE_CASE_							)

			def    _lowerCAmelCase		(	self							):
						pass










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 (
    center_crop,
    convert_to_rgb,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    OPENAI_CLIP_MEAN,
    OPENAI_CLIP_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


a      :  List[str]			     =			logging.get_logger(__name__)


if is_vision_available():
	import PIL







class 				_a				(   _lowerCAmelCase					):
			A      		=	['''pixel_values''']

			def __init__(self,   SCREAMING_SNAKE_CASE_ = True,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = PILImageResampling.BICUBIC,   SCREAMING_SNAKE_CASE_ = True,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = True,   SCREAMING_SNAKE_CASE_ = 1 / 255,   SCREAMING_SNAKE_CASE_ = True,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = True,   **SCREAMING_SNAKE_CASE_,   )       ->   None:
						super().__init__(**SCREAMING_SNAKE_CASE_					)
						UpperCAmelCase_:		Optional[Any]							      =     size if size is not None else {"""shortest_edge""": 224}
						UpperCAmelCase_:		int							      =     get_size_dict(SCREAMING_SNAKE_CASE_,   default_to_square=SCREAMING_SNAKE_CASE_					)
						UpperCAmelCase_:		Dict							      =     crop_size if crop_size is not None else {"""height""": 224, """width""": 224}
						UpperCAmelCase_:		Union[str, Any]							      =     get_size_dict(SCREAMING_SNAKE_CASE_,   default_to_square=SCREAMING_SNAKE_CASE_,   param_name="""crop_size"""					)

						UpperCAmelCase_:		Optional[int]							      =     do_resize
						UpperCAmelCase_:		Optional[int]							      =     size
						UpperCAmelCase_:		Optional[int]							      =     resample
						UpperCAmelCase_:		Tuple							      =     do_center_crop
						UpperCAmelCase_:		Optional[int]							      =     crop_size
						UpperCAmelCase_:		str							      =     do_rescale
						UpperCAmelCase_:		Optional[int]							      =     rescale_factor
						UpperCAmelCase_:		List[str]							      =     do_normalize
						UpperCAmelCase_:		Any							      =     image_mean if image_mean is not None else OPENAI_CLIP_MEAN
						UpperCAmelCase_:		Dict							      =     image_std if image_std is not None else OPENAI_CLIP_STD
						UpperCAmelCase_:		Any							      =     do_convert_rgb

			def      __snake_case       (self,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_ = PILImageResampling.BICUBIC,   SCREAMING_SNAKE_CASE_ = None,   **SCREAMING_SNAKE_CASE_,   )       ->   np.ndarray:
						UpperCAmelCase_:		Optional[Any]							      =     get_size_dict(SCREAMING_SNAKE_CASE_,   default_to_square=SCREAMING_SNAKE_CASE_					)
						if "shortest_edge" not in size:
									raise ValueError(f'The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}'					)
						UpperCAmelCase_:		Optional[Any]							      =     get_resize_output_image_size(SCREAMING_SNAKE_CASE_,   size=size["""shortest_edge"""],   default_to_square=SCREAMING_SNAKE_CASE_					)
						return resize(SCREAMING_SNAKE_CASE_,   size=SCREAMING_SNAKE_CASE_,   resample=SCREAMING_SNAKE_CASE_,   data_format=SCREAMING_SNAKE_CASE_,   **SCREAMING_SNAKE_CASE_					)

			def      __snake_case       (self,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_ = None,   **SCREAMING_SNAKE_CASE_,   )       ->   np.ndarray:
						UpperCAmelCase_:		Any							      =     get_size_dict(SCREAMING_SNAKE_CASE_					)
						if "height" not in size or "width" not in size:
									raise ValueError(f'The `size` parameter must contain the keys (height, width). Got {size.keys()}'					)
						return center_crop(SCREAMING_SNAKE_CASE_,   size=(size["""height"""], size["""width"""]),   data_format=SCREAMING_SNAKE_CASE_,   **SCREAMING_SNAKE_CASE_					)

			def      __snake_case       (self,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_ = None,   **SCREAMING_SNAKE_CASE_,   )       ->   Union[str, Any]:
						return rescale(SCREAMING_SNAKE_CASE_,   scale=SCREAMING_SNAKE_CASE_,   data_format=SCREAMING_SNAKE_CASE_,   **SCREAMING_SNAKE_CASE_					)

			def      __snake_case       (self,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_ = None,   **SCREAMING_SNAKE_CASE_,   )       ->   np.ndarray:
						return normalize(SCREAMING_SNAKE_CASE_,   mean=SCREAMING_SNAKE_CASE_,   std=SCREAMING_SNAKE_CASE_,   data_format=SCREAMING_SNAKE_CASE_,   **SCREAMING_SNAKE_CASE_					)

			def      __snake_case       (self,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = ChannelDimension.FIRST,   **SCREAMING_SNAKE_CASE_,   )       ->   PIL.Image.Image:
						UpperCAmelCase_:		Tuple							      =     do_resize if do_resize is not None else self.do_resize
						UpperCAmelCase_:		Tuple							      =     size if size is not None else self.size
						UpperCAmelCase_:		str							      =     get_size_dict(SCREAMING_SNAKE_CASE_,   param_name="""size""",   default_to_square=SCREAMING_SNAKE_CASE_					)
						UpperCAmelCase_:		List[str]							      =     resample if resample is not None else self.resample
						UpperCAmelCase_:		Optional[int]							      =     do_center_crop if do_center_crop is not None else self.do_center_crop
						UpperCAmelCase_:		Tuple							      =     crop_size if crop_size is not None else self.crop_size
						UpperCAmelCase_:		int							      =     get_size_dict(SCREAMING_SNAKE_CASE_,   param_name="""crop_size""",   default_to_square=SCREAMING_SNAKE_CASE_					)
						UpperCAmelCase_:		Union[str, Any]							      =     do_rescale if do_rescale is not None else self.do_rescale
						UpperCAmelCase_:		int							      =     rescale_factor if rescale_factor is not None else self.rescale_factor
						UpperCAmelCase_:		Tuple							      =     do_normalize if do_normalize is not None else self.do_normalize
						UpperCAmelCase_:		Dict							      =     image_mean if image_mean is not None else self.image_mean
						UpperCAmelCase_:		int							      =     image_std if image_std is not None else self.image_std
						UpperCAmelCase_:		Union[str, Any]							      =     do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb

						UpperCAmelCase_:		List[str]							      =     make_list_of_images(SCREAMING_SNAKE_CASE_					)

						if not valid_images(SCREAMING_SNAKE_CASE_					):
									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_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."""					)

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

						# All transformations expect numpy arrays.
						UpperCAmelCase_:		List[str]							      =     [to_numpy_array(SCREAMING_SNAKE_CASE_					) for image in images]

						if do_resize:
									UpperCAmelCase_:		str							      =     [self.resize(image=SCREAMING_SNAKE_CASE_,   size=SCREAMING_SNAKE_CASE_,   resample=SCREAMING_SNAKE_CASE_					) for image in images]

						if do_center_crop:
									UpperCAmelCase_:		Dict							      =     [self.center_crop(image=SCREAMING_SNAKE_CASE_,   size=SCREAMING_SNAKE_CASE_					) for image in images]

						if do_rescale:
									UpperCAmelCase_:		Optional[Any]							      =     [self.rescale(image=SCREAMING_SNAKE_CASE_,   scale=SCREAMING_SNAKE_CASE_					) for image in images]

						if do_normalize:
									UpperCAmelCase_:		Dict							      =     [self.normalize(image=SCREAMING_SNAKE_CASE_,   mean=SCREAMING_SNAKE_CASE_,   std=SCREAMING_SNAKE_CASE_					) for image in images]

						UpperCAmelCase_:		Tuple							      =     [to_channel_dimension_format(SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_					) for image in images]

						UpperCAmelCase_:		Union[str, Any]							      =     {"""pixel_values""": images}
						return BatchFeature(data=SCREAMING_SNAKE_CASE_,   tensor_type=SCREAMING_SNAKE_CASE_					)






