



import importlib.util
import weakref
from functools import partialmethod

from .dependency_versions_check import dep_version_check
from .utils import is_accelerate_available, is_torch_available, logging


if is_torch_available():
	import torch

UpperCAmelCase :				str							=logging.get_logger(__name__)



def  _lowerCAmelCase     ():
					return importlib.util.find_spec("deepspeed") is not None


if is_accelerate_available() and is_deepspeed_available():
	from accelerate.utils.deepspeed import HfDeepSpeedConfig as DeepSpeedConfig
else:
	# Inherits from a dummy `object` if accelerate is not available, so that python succeeds to import this file.
	# Deepspeed glue code will never inherit this dummy object as it checks if accelerate is available.
	from builtins import object as DeepSpeedConfig


class    _lowercase (lowerCamelCase_   ):
				'''simple docstring'''







				def __init__(			self  ,			snake_case__     ):

									'''simple docstring'''


									set_hf_deepspeed_config(self     )
									dep_version_check("accelerate"     )
									dep_version_check("deepspeed"     )
									super().__init__(__UpperCAmelCase     )




class    _lowercase (lowerCamelCase_   ):
				'''simple docstring'''







				def __init__(			self  ,			snake_case__     ):

									'''simple docstring'''


									super().__init__(__UpperCAmelCase     )
									UpperCamelCase_			= None
									UpperCamelCase_			= []

				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									if self._dtype is None:
														raise ValueError("trainer_config_process() wasn\'t called yet to tell dtype"     )
									return self._dtype

				def    _lowerCamelCase       (			self  ,			snake_case__     ):

									'''simple docstring'''


									UpperCamelCase_			= self.get_value(__UpperCAmelCase     )
									if val is None:
														return False
									else:
														return val == "auto"

				def    _lowerCamelCase       (			self  ,			snake_case__  ,			snake_case__  ,			snake_case__=None  ,			snake_case__=True     ):

									'''simple docstring'''


									UpperCamelCase_	,     UpperCamelCase_			= self.find_config_node(__UpperCAmelCase     )
									if config is None:
														return

									if config.get(__UpperCAmelCase     ) == "auto":
														UpperCamelCase_			= hf_val
														return

									if not must_match:
														return

									UpperCamelCase_			= config.get(__UpperCAmelCase     )
									if ds_val is not None and ds_val != hf_val:
														self.mismatches.append(F"""- ds {ds_key_long}={ds_val} vs hf {hf_key}={hf_val}"""     )

				lowercase__     =    partialmethod(lowerCamelCase_   , must_match=lowerCamelCase_   )

				def    _lowerCamelCase       (			self  ,			snake_case__     ):

									'''simple docstring'''


									UpperCamelCase_			= args.world_size * args.per_device_train_batch_size * args.gradient_accumulation_steps
									self.fill_match(
									    "train_micro_batch_size_per_gpu"  ,			args.per_device_train_batch_size  ,			"per_device_train_batch_size"     )
									self.fill_match("gradient_accumulation_steps"  ,			args.gradient_accumulation_steps  ,			"gradient_accumulation_steps"     )
									self.fill_match("train_batch_size"  ,			__UpperCAmelCase  ,			"train_batch_size (calculated)"     )
									self.fill_match("gradient_clipping"  ,			args.max_grad_norm  ,			"max_grad_norm"     )

									self.fill_match("optimizer.params.lr"  ,			args.learning_rate  ,			"learning_rate"     )
									self.fill_match("optimizer.params.betas"  ,			[args.adam_betaa, args.adam_betaa]  ,			"adam_beta1+adam_beta2"     )
									self.fill_match("optimizer.params.eps"  ,			args.adam_epsilon  ,			"adam_epsilon"     )
									self.fill_match("optimizer.params.weight_decay"  ,			args.weight_decay  ,			"weight_decay"     )

									self.fill_only("scheduler.params.warmup_min_lr"  ,			0     )  # not a trainer arg
									self.fill_match("scheduler.params.warmup_max_lr"  ,			args.learning_rate  ,			"learning_rate"     )
									# total_num_steps - will get set in trainer_config_finalize

									# fp16
									if args.fpaa or args.fpaa_full_eval:
														UpperCamelCase_			= "apex" if args.fpaa_backend == "apex" else "amp"
									else:
														UpperCamelCase_			= None

									if args.save_on_each_node:
														# deepspeed uses shared storage by default. Let's override this setting if save_on_each_node == True
														UpperCamelCase_			= self.config.get("checkpoint"  ,			{}     )
														UpperCamelCase_			= args.save_on_each_node

									# amp: similar to the pytorch native amp - it has a bunch of optional params but we won't set
									# any here unless the user did the work
									self.fill_match(
									    "fp16.enabled"  ,			((args.fpaa or args.fpaa_full_eval) and fpaa_backend == "amp")  ,			"fp16|fp16_full_eval+fp16_backend(amp)"  ,			)

									# apex: delegates amp work to apex (which needs to be available), but it cannot be used with any
									# ZeRO features
									self.fill_match("amp.enabled"  ,			fpaa_backend == "apex"  ,			"fp16+fp16_backend(apex)"     )
									self.fill_match("amp.opt_level"  ,			args.fpaa_opt_level  ,			"fp16_opt_level"     )

									self.fill_match("bf16.enabled"  ,			(args.bfaa or args.bfaa_full_eval)  ,			"bf16|bf16_full_eval"     )

									# deepspeed's default mode is fp16 unless there is a config that says differently
									if self.is_true("bf16.enabled"     ):
														UpperCamelCase_			= torch.bfloataa
									elif self.is_false("fp16.enabled"     ):
														UpperCamelCase_			= torch.floataa
									else:
														UpperCamelCase_			= torch.floataa

				def    _lowerCamelCase       (			self  ,			snake_case__  ,			snake_case__  ,			snake_case__     ):

									'''simple docstring'''


									UpperCamelCase_			= [
									    "zero_optimization.reduce_bucket_size",
									    "zero_optimization.stage3_prefetch_bucket_size",
									    "zero_optimization.stage3_param_persistence_threshold",
									]
									UpperCamelCase_			= [x for x in hidden_size_based_keys if self.is_auto(__UpperCAmelCase     )]

									if len(__UpperCAmelCase     ) > 0:
														if hasattr(model.config  ,			"hidden_size"     ):
																			UpperCamelCase_			= model.config.hidden_size
														elif hasattr(model.config  ,			"hidden_sizes"     ):
																			# if there are many hidden sizes pick the largest one
																			UpperCamelCase_			= max(model.config.hidden_sizes     )
														else:
																			raise ValueError(
																			    "The model\'s config file has neither `hidden_size` nor `hidden_sizes` entry, "
																			    "therefore it\'s not possible to automatically fill out the following `auto` entries "
																			    F"""in the DeepSpeed config file: {hidden_size_auto_keys}. You can fix that by replacing """
																			    "`auto` values for these keys with an integer value of your choice."     )

														self.fill_only("zero_optimization.reduce_bucket_size"  ,			hidden_size * hidden_size     )
														if self.is_zeroa():
																			# automatically assign the optimal config values based on model config
																			self.fill_only("zero_optimization.stage3_prefetch_bucket_size"  ,			0.9 * hidden_size * hidden_size     )
																			self.fill_only("zero_optimization.stage3_param_persistence_threshold"  ,			10 * hidden_size     )

        # scheduler
									self.fill_match("scheduler.params.total_num_steps"  ,			__UpperCAmelCase  ,			"num_training_steps (calculated)"     )
									self.fill_match("scheduler.params.warmup_num_steps"  ,			args.get_warmup_steps(__UpperCAmelCase     )  ,			"warmup_steps"     )

									if len(self.mismatches     ) > 0:
														UpperCamelCase_			= "\n".join(self.mismatches     )
														raise ValueError(
														    "Please correct the following DeepSpeed config values that mismatch TrainingArguments"
														    F""" values:\n{mismatches}\nThe easiest method is to set these DeepSpeed config values to \'auto\'."""     )




UpperCAmelCase :				Union[str, Any]							=None



def  _lowerCAmelCase     (_lowerCAmelCase):
					global _hf_deepspeed_config_weak_ref
					# will go away automatically when HfDeepSpeedConfig is destroyed (when TrainingArguments is destroyed)
					UpperCamelCase_			= weakref.ref(__snake_case)



def  _lowerCAmelCase     ():
					global _hf_deepspeed_config_weak_ref
					UpperCamelCase_			= None



def  _lowerCAmelCase     ():


					if _hf_deepspeed_config_weak_ref is not None and _hf_deepspeed_config_weak_ref() is not None:
										return _hf_deepspeed_config_weak_ref().is_zeroa()
					else:
										return False



def  _lowerCAmelCase     ():


					if _hf_deepspeed_config_weak_ref is not None and _hf_deepspeed_config_weak_ref() is not None:
										return _hf_deepspeed_config_weak_ref().config
					else:
										return None



def  _lowerCAmelCase     (_lowerCAmelCase ,						_lowerCAmelCase ,						_lowerCAmelCase ,						_lowerCAmelCase ,						_lowerCAmelCase):
					from accelerate.utils import DummyOptim, DummyScheduler

					UpperCamelCase_			= hf_deepspeed_config.config

					# Optimizer + Scheduler
					# Currently supported combos:
					# 1. DS scheduler + DS optimizer: Yes
					# 2. HF scheduler + HF optimizer: Yes
					# 3. DS scheduler + HF optimizer: Yes
					# 4. HF scheduler + DS optimizer: No
					#
					# Unless Offload is enabled in which case it's:
					# 1. DS scheduler + DS optimizer: Yes
					# 2. HF scheduler + HF optimizer: Mostly*
					# 3. DS scheduler + HF optimizer: Mostly*
					# 4. HF scheduler + DS optimizer: No
					#
					# Mostly*: All non-native DeepSpeed optimizers that have both CPU and GPU implementation should work (except LAMB)

					UpperCamelCase_			= None
					if "optimizer" in config:
										if args.adafactor:
															raise ValueError(
															    "--adafactor was passed, but also found `optimizer` configured in the DeepSpeed config. "
															    "Only one optimizer can be configured.")
										UpperCamelCase_			= DummyOptim(params=__snake_case)
					else:
										if hf_deepspeed_config.is_offload():
															logger.info(
															    "Detected ZeRO Offload and non-DeepSpeed optimizers: This combination should work as long as the"
															    " custom optimizer has both CPU and GPU implementation (except LAMB)")

										# ds supports Adam, OneBitAdam, and Lamb optimizers and can import other optimizers from torch.
										# But trainer uses AdamW by default.
										UpperCamelCase_			= trainer.create_optimizer()
										# To use other optimizers requires voiding warranty with: `zero_allow_untested_optimizer`
										UpperCamelCase_			= True

					UpperCamelCase_			= None
					if "scheduler" in config:
										UpperCamelCase_			= DummyScheduler(__snake_case)
					else:
										if isinstance(__snake_case ,						__snake_case):
															raise ValueError(
															    "Found `optimizer` configured in the DeepSpeed config, but no `scheduler`. "
															    "Please configure a scheduler in the DeepSpeed config.")
										UpperCamelCase_			= trainer.create_scheduler(num_training_steps=__snake_case ,						optimizer=__snake_case)

					return optimizer, lr_scheduler



def  _lowerCAmelCase     (_lowerCAmelCase ,						_lowerCAmelCase ,						_lowerCAmelCase=False):
					from deepspeed.utils import logger as ds_logger

					UpperCamelCase_			= trainer.model
					UpperCamelCase_			= trainer.args

					UpperCamelCase_			= trainer.accelerator.state.deepspeed_plugin.hf_ds_config

					# resume config update - some bits like `model` and `num_training_steps` only become available during train
					hf_deepspeed_config.trainer_config_finalize(__snake_case ,						__snake_case ,						__snake_case)

					# set the Deepspeed log level consistent with the Trainer
					ds_logger.setLevel(args.get_process_log_level())

					if inference:
										# only Z3 makes sense for the inference
										if not hf_deepspeed_config.is_zeroa():
															raise ValueError("ZeRO inference only makes sense with ZeRO Stage 3 - please adjust your config")

										# in case the training config is re-used for inference
										hf_deepspeed_config.del_config_sub_tree("optimizer")
										hf_deepspeed_config.del_config_sub_tree("lr_scheduler")
										UpperCamelCase_	,     UpperCamelCase_			= None, None
										UpperCamelCase_			= None
					else:
										UpperCamelCase_			= None  # important for when deepspeed_init is used as re-init
										UpperCamelCase_			= list(filter(lambda _lowerCAmelCase: p.requires_grad ,						model.parameters()))
										UpperCamelCase_	,     UpperCamelCase_			= deepspeed_optim_sched(
										    __snake_case ,						__snake_case ,						__snake_case ,						__snake_case ,						__snake_case)

					# keep for quick debug:
					# from pprint import pprint; pprint(config)

					return optimizer, lr_scheduler






def  _lowerCAmelCase     (_lowerCAmelCase ,						_lowerCAmelCase):
					import glob

					UpperCamelCase_			= sorted(glob.glob(f"""{checkpoint_path}/global_step*"""))

					if len(__snake_case) > 0:
										logger.info(f"""Attempting to resume from {checkpoint_path}""")
										# this magically updates self.optimizer and self.lr_scheduler
										UpperCamelCase_	,     UpperCamelCase_			= deepspeed_engine.load_checkpoint(
										    __snake_case ,						load_optimizer_states=__snake_case ,						load_lr_scheduler_states=__snake_case)
										if load_path is None:
															raise ValueError(f"""[deepspeed] failed to resume from checkpoint {checkpoint_path}""")
					else:
										raise ValueError(f"""Can\'t find a valid checkpoint at {checkpoint_path}""")






import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin


if is_torch_available():
				import torch

if is_vision_available():
				from PIL import Image

				from transformers import CLIPImageProcessor




class     A					(				unittest.TestCase       ):







							def __init__(    self   :	Any   ,     __UpperCAmelCase   :	Optional[int]   ,     __UpperCAmelCase   :	List[Any]=7   ,     __UpperCAmelCase   :	Union[str, Any]=3   ,     __UpperCAmelCase   :	Optional[Any]=18   ,     __UpperCAmelCase   :	List[str]=30   ,     __UpperCAmelCase   :	int=400   ,     __UpperCAmelCase   :	List[Any]=True   ,     __UpperCAmelCase   :	Tuple=None   ,     __UpperCAmelCase   :	Optional[Any]=True   ,     __UpperCAmelCase   :	Any=None   ,     __UpperCAmelCase   :	Optional[int]=True   ,     __UpperCAmelCase   :	List[str]=[0.48_145_466, 0.4_578_275, 0.40_821_073]   ,     __UpperCAmelCase   :	List[Any]=[0.26_862_954, 0.26_130_258, 0.27_577_711]   ,     __UpperCAmelCase   :	Dict=True   ,     )		->					Tuple:

										"""simple docstring"""



										UpperCamelCase_     				= size if size is not None else {'shortest_edge': 20}
										UpperCamelCase_     				= crop_size if crop_size is not None else {'height': 18, 'width': 18}
										UpperCamelCase_     				= parent
										UpperCamelCase_     				= batch_size
										UpperCamelCase_     				= num_channels
										UpperCamelCase_     				= image_size
										UpperCamelCase_     				= min_resolution
										UpperCamelCase_     				= max_resolution
										UpperCamelCase_     				= do_resize
										UpperCamelCase_     				= size
										UpperCamelCase_     				= do_center_crop
										UpperCamelCase_     				= crop_size
										UpperCamelCase_     				= do_normalize
										UpperCamelCase_     				= image_mean
										UpperCamelCase_     				= image_std
										UpperCamelCase_     				= do_convert_rgb







							def        lowercase__							(    self   :	Tuple				)		->					List[Any]:

										"""simple docstring"""



										return {
										    "do_resize": self.do_resize,
										    "size": self.size,
										    "do_center_crop": self.do_center_crop,
										    "crop_size": self.crop_size,
										    "do_normalize": self.do_normalize,
										    "image_mean": self.image_mean,
										    "image_std": self.image_std,
										    "do_convert_rgb": self.do_convert_rgb,
										}







							def        lowercase__							(    self   :	List[Any]   ,     __UpperCAmelCase   :	str=False   ,     __UpperCAmelCase   :	Tuple=False   ,     __UpperCAmelCase   :	Optional[int]=False				)		->					Any:

										"""simple docstring"""



										assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

										if equal_resolution:
													UpperCamelCase_     				= []
													for i in range(self.batch_size				):
																image_inputs.append(
																    np.random.randint(
																        255   ,     size=(self.num_channels, self.max_resolution, self.max_resolution)   ,     dtype=np.uinta				)				)
										else:
													UpperCamelCase_     				= []
													for i in range(self.batch_size				):
																UpperCamelCase_				,   UpperCamelCase_     				= np.random.choice(np.arange(self.min_resolution   ,     self.max_resolution				)   ,     2				)
																image_inputs.append(np.random.randint(255   ,     size=(self.num_channels, width, height)   ,     dtype=np.uinta				)				)

										if not numpify and not torchify:
													# PIL expects the channel dimension as last dimension
													UpperCamelCase_     				= [Image.fromarray(np.moveaxis(__UpperCAmelCase   ,     0   ,     -1				)				) for x in image_inputs]

										if torchify:
													UpperCamelCase_     				= [torch.from_numpy(__UpperCAmelCase				) for x in image_inputs]

										return image_inputs







@require_torch
@require_vision
class     A					(				lowerCamelCase_  ,						unittest.TestCase       ):
							_SCREAMING_SNAKE_CASE  :		Any			  =       CLIPImageProcessor if is_vision_available() else None







							def        lowercase__							(    self   :	Dict				)		->					List[str]:

										"""simple docstring"""



										UpperCamelCase_     				= CLIPImageProcessingTester(self				)







							@property
							def        lowercase__							(    self   :	Optional[int]				)		->					Optional[Any]:

										"""simple docstring"""



										return self.image_processor_tester.prepare_image_processor_dict()







							def        lowercase__							(    self   :	Tuple				)		->					Tuple:

										"""simple docstring"""



										UpperCamelCase_     				= self.image_processing_class(**self.image_processor_dict				)
										self.assertTrue(hasattr(__UpperCAmelCase   ,     'do_resize'				)				)
										self.assertTrue(hasattr(__UpperCAmelCase   ,     'size'				)				)
										self.assertTrue(hasattr(__UpperCAmelCase   ,     'do_center_crop'				)				)
										self.assertTrue(hasattr(__UpperCAmelCase   ,     'center_crop'				)				)
										self.assertTrue(hasattr(__UpperCAmelCase   ,     'do_normalize'				)				)
										self.assertTrue(hasattr(__UpperCAmelCase   ,     'image_mean'				)				)
										self.assertTrue(hasattr(__UpperCAmelCase   ,     'image_std'				)				)
										self.assertTrue(hasattr(__UpperCAmelCase   ,     'do_convert_rgb'				)				)







							def        lowercase__							(    self   :	Optional[int]				)		->					Tuple:

										"""simple docstring"""



										UpperCamelCase_     				= self.image_processing_class.from_dict(self.image_processor_dict				)
										self.assertEqual(image_processor.size   ,     {'shortest_edge': 20}				)
										self.assertEqual(image_processor.crop_size   ,     {'height': 18, 'width': 18}				)

										UpperCamelCase_     				= self.image_processing_class.from_dict(self.image_processor_dict   ,     size=42   ,     crop_size=84				)
										self.assertEqual(image_processor.size   ,     {'shortest_edge': 42}				)
										self.assertEqual(image_processor.crop_size   ,     {'height': 84, 'width': 84}				)







							def        lowercase__							(    self   :	Union[str, Any]				)		->					Optional[int]:

										"""simple docstring"""



										pass







							def        lowercase__							(    self   :	int				)		->					Optional[int]:

										"""simple docstring"""



										UpperCamelCase_     				= self.image_processing_class(**self.image_processor_dict				)
										# create random PIL images
										UpperCamelCase_     				= self.image_processor_tester.prepare_inputs(equal_resolution=__UpperCAmelCase				)
										for image in image_inputs:
													self.assertIsInstance(__UpperCAmelCase   ,     Image.Image				)

										# Test not batched input
										UpperCamelCase_     				= image_processing(image_inputs[0]   ,     return_tensors='pt'				).pixel_values
										self.assertEqual(
										    encoded_images.shape   ,     (
										        1,
										        self.image_processor_tester.num_channels,
										        self.image_processor_tester.crop_size['height'],
										        self.image_processor_tester.crop_size['width'],
										    )   ,     )

										# Test batched
										UpperCamelCase_     				= image_processing(__UpperCAmelCase   ,     return_tensors='pt'				).pixel_values
										self.assertEqual(
										    encoded_images.shape   ,     (
										        self.image_processor_tester.batch_size,
										        self.image_processor_tester.num_channels,
										        self.image_processor_tester.crop_size['height'],
										        self.image_processor_tester.crop_size['width'],
										    )   ,     )







							def        lowercase__							(    self   :	Optional[Any]				)		->					Tuple:

										"""simple docstring"""



										UpperCamelCase_     				= self.image_processing_class(**self.image_processor_dict				)
										# create random numpy tensors
										UpperCamelCase_     				= self.image_processor_tester.prepare_inputs(equal_resolution=__UpperCAmelCase   ,     numpify=__UpperCAmelCase				)
										for image in image_inputs:
													self.assertIsInstance(__UpperCAmelCase   ,     np.ndarray				)

										# Test not batched input
										UpperCamelCase_     				= image_processing(image_inputs[0]   ,     return_tensors='pt'				).pixel_values
										self.assertEqual(
										    encoded_images.shape   ,     (
										        1,
										        self.image_processor_tester.num_channels,
										        self.image_processor_tester.crop_size['height'],
										        self.image_processor_tester.crop_size['width'],
										    )   ,     )

										# Test batched
										UpperCamelCase_     				= image_processing(__UpperCAmelCase   ,     return_tensors='pt'				).pixel_values
										self.assertEqual(
										    encoded_images.shape   ,     (
										        self.image_processor_tester.batch_size,
										        self.image_processor_tester.num_channels,
										        self.image_processor_tester.crop_size['height'],
										        self.image_processor_tester.crop_size['width'],
										    )   ,     )







							def        lowercase__							(    self   :	Optional[Any]				)		->					Any:

										"""simple docstring"""



										UpperCamelCase_     				= self.image_processing_class(**self.image_processor_dict				)
										# create random PyTorch tensors
										UpperCamelCase_     				= self.image_processor_tester.prepare_inputs(equal_resolution=__UpperCAmelCase   ,     torchify=__UpperCAmelCase				)
										for image in image_inputs:
													self.assertIsInstance(__UpperCAmelCase   ,     torch.Tensor				)

										# Test not batched input
										UpperCamelCase_     				= image_processing(image_inputs[0]   ,     return_tensors='pt'				).pixel_values
										self.assertEqual(
										    encoded_images.shape   ,     (
										        1,
										        self.image_processor_tester.num_channels,
										        self.image_processor_tester.crop_size['height'],
										        self.image_processor_tester.crop_size['width'],
										    )   ,     )

										# Test batched
										UpperCamelCase_     				= image_processing(__UpperCAmelCase   ,     return_tensors='pt'				).pixel_values
										self.assertEqual(
										    encoded_images.shape   ,     (
										        self.image_processor_tester.batch_size,
										        self.image_processor_tester.num_channels,
										        self.image_processor_tester.crop_size['height'],
										        self.image_processor_tester.crop_size['width'],
										    )   ,     )







@require_torch
@require_vision
class     A					(				lowerCamelCase_  ,						unittest.TestCase       ):
							_SCREAMING_SNAKE_CASE  :		str			  =       CLIPImageProcessor if is_vision_available() else None







							def        lowercase__							(    self   :	str				)		->					Any:

										"""simple docstring"""



										UpperCamelCase_     				= CLIPImageProcessingTester(self   ,     num_channels=4				)
										UpperCamelCase_     				= 3







							@property
							def        lowercase__							(    self   :	Dict				)		->					str:

										"""simple docstring"""



										return self.image_processor_tester.prepare_image_processor_dict()







							def        lowercase__							(    self   :	Optional[int]				)		->					List[str]:

										"""simple docstring"""



										UpperCamelCase_     				= self.image_processing_class(**self.image_processor_dict				)
										self.assertTrue(hasattr(__UpperCAmelCase   ,     'do_resize'				)				)
										self.assertTrue(hasattr(__UpperCAmelCase   ,     'size'				)				)
										self.assertTrue(hasattr(__UpperCAmelCase   ,     'do_center_crop'				)				)
										self.assertTrue(hasattr(__UpperCAmelCase   ,     'center_crop'				)				)
										self.assertTrue(hasattr(__UpperCAmelCase   ,     'do_normalize'				)				)
										self.assertTrue(hasattr(__UpperCAmelCase   ,     'image_mean'				)				)
										self.assertTrue(hasattr(__UpperCAmelCase   ,     'image_std'				)				)
										self.assertTrue(hasattr(__UpperCAmelCase   ,     'do_convert_rgb'				)				)







							def        lowercase__							(    self   :	int				)		->					Any:

										"""simple docstring"""



										pass







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

										"""simple docstring"""



										UpperCamelCase_     				= self.image_processing_class(**self.image_processor_dict				)
										# create random PIL images
										UpperCamelCase_     				= self.image_processor_tester.prepare_inputs(equal_resolution=__UpperCAmelCase				)
										for image in image_inputs:
													self.assertIsInstance(__UpperCAmelCase   ,     Image.Image				)

										# Test not batched input
										UpperCamelCase_     				= image_processing(image_inputs[0]   ,     return_tensors='pt'				).pixel_values
										self.assertEqual(
										    encoded_images.shape   ,     (
										        1,
										        self.expected_encoded_image_num_channels,
										        self.image_processor_tester.crop_size['height'],
										        self.image_processor_tester.crop_size['width'],
										    )   ,     )

										# Test batched
										UpperCamelCase_     				= image_processing(__UpperCAmelCase   ,     return_tensors='pt'				).pixel_values
										self.assertEqual(
										    encoded_images.shape   ,     (
										        self.image_processor_tester.batch_size,
										        self.expected_encoded_image_num_channels,
										        self.image_processor_tester.crop_size['height'],
										        self.image_processor_tester.crop_size['width'],
										    )   ,     )
