

"""simple docstring"""





from __future__ import annotations

import copy
import os
import tempfile
from importlib import import_module
from math import isnan

from transformers import is_tf_available
from transformers.models.auto import get_values
from transformers.testing_utils import _tf_gpu_memory_limit, require_tf, slow

from ..test_modeling_tf_common import ids_tensor


if is_tf_available():
							import numpy as np
							import tensorflow as tf

							from transformers import (
							    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
							    TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
							    TF_MODEL_FOR_MASKED_LM_MAPPING,
							    TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
							    TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
							    TF_MODEL_FOR_PRETRAINING_MAPPING,
							    TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
							    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
							    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
							    TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
							    TFSharedEmbeddings,
							)

							if _tf_gpu_memory_limit is not None:
														__UpperCamelCase						:   List[str]							   =	tf.config.list_physical_devices('''GPU''')
														for gpu in gpus:
																					# Restrict TensorFlow to only allocate x GB of memory on the GPUs
																					try:
																												tf.config.set_logical_device_configuration(
																												    gpu, [tf.config.LogicalDeviceConfiguration(memory_limit=_tf_gpu_memory_limit)]
																												)
																												__UpperCamelCase						:   Tuple							   =	tf.config.list_logical_devices('''GPU''')
																												print('''Logical GPUs''', logical_gpus)
																					except RuntimeError as e:
																												# Virtual devices must be set before GPUs have been initialized
																												print(e)







@require_tf
class        SCREAMING_SNAKE_CASE      :






					"""simple docstring"""



					lowercase__       				= None
					lowercase__       				= ()
					lowercase__       				= ()
					lowercase__       				= True
					lowercase__       				= True
					lowercase__       				= True
					lowercase__       				= False







					def  __lowerCAmelCase				( self    :       Optional[Any]     ,lowercase_    :       List[str]     ,lowercase_    :       List[str]     ,lowercase_    :       int=False	):
						lowerCAmelCase__			:		List[str]						       =			copy.deepcopy(lowercase_	)

						if model_class in get_values(lowercase_	):
							lowerCAmelCase__			:		str						       =			{
							    k: tf.tile(tf.expand_dims(lowercase_     ,1	)     ,(1, self.model_tester.num_choices) + (1,) * (v.ndim - 1)	)
							    if isinstance(lowercase_     ,tf.Tensor	) and v.ndim > 0
							    else v
							    for k, v in inputs_dict.items()
							}

						if return_labels:
							if model_class in get_values(lowercase_	):
								lowerCAmelCase__			:		Any						       =			tf.ones(self.model_tester.batch_size     ,dtype=tf.intaa	)
							elif model_class in get_values(lowercase_	):
								lowerCAmelCase__			:		Dict						       =			tf.zeros(self.model_tester.batch_size     ,dtype=tf.intaa	)
								lowerCAmelCase__			:		Optional[int]						       =			tf.zeros(self.model_tester.batch_size     ,dtype=tf.intaa	)
							elif model_class in [
							    *get_values(lowercase_	),
							    *get_values(lowercase_	),
							]:
								lowerCAmelCase__			:		Dict						       =			tf.zeros(self.model_tester.batch_size     ,dtype=tf.intaa	)
							elif model_class in get_values(lowercase_	):
								lowerCAmelCase__			:		Any						       =			tf.zeros(self.model_tester.batch_size     ,dtype=tf.intaa	)
							elif model_class in [
							    *get_values(lowercase_	),
							    *get_values(lowercase_	),
							    *get_values(lowercase_	),
							    *get_values(lowercase_	),
							    *get_values(lowercase_	),
							]:
								lowerCAmelCase__			:		Union[str, Any]						       =			tf.zeros(
								    (self.model_tester.batch_size, self.model_tester.seq_length)     ,dtype=tf.intaa	)
						return inputs_dict







					@slow
					def  __lowerCAmelCase				( self    :       Union[str, Any]	):
						lowerCAmelCase__       ,lowerCAmelCase__			:		Union[str, Any]						       =			self.model_tester.prepare_config_and_inputs_for_common()
						for model_class in self.all_model_classes[:2]:
							lowerCAmelCase__			:		Dict						       =			self._prepare_for_class(lowercase_     ,lowercase_	)
							lowerCAmelCase__			:		Dict						       =			model_class(lowercase_	)

							@tf.function
							def run_in_graph_mode():
								return model(lowercase_	)

							lowerCAmelCase__			:		Dict						       =			run_in_graph_mode()
							self.assertIsNotNone(lowercase_	)







					@slow
					def  __lowerCAmelCase				( self    :       Optional[int]	):
						lowerCAmelCase__       ,lowerCAmelCase__			:		List[str]						       =			self.model_tester.prepare_config_and_inputs_for_common()
						for model_class in self.all_model_classes[:2]:
							lowerCAmelCase__			:		Any						       =			self._prepare_for_class(lowercase_     ,lowercase_	)
							lowerCAmelCase__			:		Optional[int]						       =			model_class(lowercase_	)

							@tf.function(experimental_compile=lowercase_	)
							def run_in_graph_mode():
								return model(lowercase_	)

							lowerCAmelCase__			:		Union[str, Any]						       =			run_in_graph_mode()
							self.assertIsNotNone(lowercase_	)







					@slow
					def  __lowerCAmelCase				( self    :       int	):
						# This is a copy of the test_keras_fit method, but we use XLA compilation instead of eager
						lowerCAmelCase__       ,lowerCAmelCase__			:		Any						       =			self.model_tester.prepare_config_and_inputs_for_common()
						for model_class in self.all_model_classes[:2]:
							lowerCAmelCase__			:		Dict						       =			model_class(lowercase_	)
							if getattr(lowercase_     ,'''hf_compute_loss'''     ,lowercase_	):
								# Test that model correctly compute the loss with kwargs
								lowerCAmelCase__			:		int						       =			self._prepare_for_class(inputs_dict.copy()     ,lowercase_     ,return_labels=lowercase_	)
								# Is there a better way to remove these decoder inputs?
								lowerCAmelCase__			:		Dict						       =			{
								    key: val
								    for key, val in prepared_for_class.items()
								    if key not in ('''head_mask''', '''decoder_head_mask''', '''cross_attn_head_mask''', '''decoder_input_ids''')
								}

								lowerCAmelCase__			:		Union[str, Any]						       =			{
								    '''labels''',
								    '''label''',
								    '''label_ids''',
								    '''start_positions''',
								    '''start_position''',
								    '''end_positions''',
								    '''end_position''',
								    '''next_sentence_label''',
								}
								lowerCAmelCase__			:		Optional[int]						       =			possible_label_cols.intersection(set(lowercase_	)	)
								self.assertGreater(len(lowercase_	)     ,0     ,msg='''No matching label names found!'''	)
								lowerCAmelCase__			:		Optional[Any]						       =			{key: val for key, val in prepared_for_class.items() if key in label_names}
								lowerCAmelCase__			:		Any						       =			{key: val for key, val in prepared_for_class.items() if key not in label_names}
								self.assertGreater(len(lowercase_	)     ,0	)

								# Make sure it works with XLA!
								model.compile(optimizer=tf.keras.optimizers.SGD(0.0	)     ,jit_compile=lowercase_	)
								# Make sure the model fits without crashing regardless of where we pass the labels
								lowerCAmelCase__			:		Optional[Any]						       =			model.fit(
								    lowercase_     ,validation_data=lowercase_     ,steps_per_epoch=1     ,validation_steps=1     ,shuffle=lowercase_     ,verbose=0     ,)
								lowerCAmelCase__			:		List[Any]						       =			history.history['''loss'''][0]
								self.assertTrue(not isnan(lowercase_	)	)
								lowerCAmelCase__			:		Union[str, Any]						       =			history.history['''val_loss'''][0]
								self.assertTrue(not isnan(lowercase_	)	)

								# Now test it with separate labels, to make sure that path works in XLA too.
								lowerCAmelCase__			:		Tuple						       =			model_class(lowercase_	)
								model.compile(optimizer=tf.keras.optimizers.SGD(0.0	)     ,jit_compile=lowercase_	)
								lowerCAmelCase__			:		Optional[Any]						       =			model.fit(
								    lowercase_     ,lowercase_     ,validation_data=(inputs_minus_labels, labels)     ,steps_per_epoch=1     ,validation_steps=1     ,shuffle=lowercase_     ,verbose=0     ,)

								lowerCAmelCase__			:		Optional[Any]						       =			history.history['''loss'''][0]
								self.assertTrue(not isnan(lowercase_	)	)
								lowerCAmelCase__			:		Dict						       =			history.history['''val_loss'''][0]
								self.assertTrue(not isnan(lowercase_	)	)







					@slow
					def  __lowerCAmelCase				( self    :       Dict	):
						lowerCAmelCase__       ,lowerCAmelCase__			:		Optional[int]						       =			self.model_tester.prepare_config_and_inputs_for_common()
						lowerCAmelCase__			:		Dict						       =			True
						lowerCAmelCase__			:		int						       =			True

						if hasattr(lowercase_     ,'''use_cache'''	):
							lowerCAmelCase__			:		str						       =			True

						lowerCAmelCase__			:		int						       =			getattr(self.model_tester     ,'''encoder_seq_length'''     ,self.model_tester.seq_length	)
						lowerCAmelCase__			:		Any						       =			getattr(self.model_tester     ,'''key_length'''     ,lowercase_	)

						for model_class in self.all_model_classes[:2]:
							lowerCAmelCase__			:		int						       =			self._prepare_for_class(lowercase_     ,lowercase_	)
							lowerCAmelCase__			:		Optional[int]						       =			model_class(lowercase_	)
							model.build()
							lowerCAmelCase__			:		Optional[int]						       =			len(model(lowercase_	)	)

							for key in list(class_inputs_dict.keys()	):
								# Remove keys not in the serving signature, as the SavedModel will not be compiled to deal with them
								if key not in model.input_signature:
									del class_inputs_dict[key]
								# Check it's a tensor, in case the inputs dict has some bools in it too
								elif isinstance(class_inputs_dict[key]     ,tf.Tensor	) and class_inputs_dict[key].dtype.is_integer:
									lowerCAmelCase__			:		Optional[int]						       =			tf.cast(class_inputs_dict[key]     ,tf.intaa	)

							if set(class_inputs_dict.keys()	) != set(model.input_signature.keys()	):
								continue  # Some models have inputs that the preparation functions don't create, we skip those

							with tempfile.TemporaryDirectory() as tmpdirname:
								model.save_pretrained(lowercase_     ,saved_model=lowercase_	)
								lowerCAmelCase__			:		Optional[int]						       =			os.path.join(lowercase_     ,'''saved_model'''     ,'''1'''	)
								lowerCAmelCase__			:		Optional[int]						       =			tf.keras.models.load_model(lowercase_	)
								lowerCAmelCase__			:		Optional[Any]						       =			model(lowercase_	)

								if self.is_encoder_decoder:
									lowerCAmelCase__			:		int						       =			outputs['''encoder_hidden_states''']
									lowerCAmelCase__			:		Union[str, Any]						       =			outputs['''encoder_attentions''']
								else:
									lowerCAmelCase__			:		Optional[int]						       =			outputs['''hidden_states''']
									lowerCAmelCase__			:		Dict						       =			outputs['''attentions''']

								self.assertEqual(len(lowercase_	)     ,lowercase_	)

								lowerCAmelCase__			:		str						       =			getattr(
								    self.model_tester     ,'''expected_num_hidden_layers'''     ,self.model_tester.num_hidden_layers + 1	)

								self.assertEqual(len(lowercase_	)     ,lowercase_	)
								self.assertListEqual(
								    list(output_hidden_states[0].shape[-2:]	)     ,[self.model_tester.seq_length, self.model_tester.hidden_size]     ,)

								self.assertEqual(len(lowercase_	)     ,self.model_tester.num_hidden_layers	)
								self.assertListEqual(
								    list(output_attentions[0].shape[-3:]	)     ,[self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]     ,)







					@slow
					def  __lowerCAmelCase				( self    :       int	):
						tf.keras.mixed_precision.set_global_policy('''mixed_float16'''	)

						# try/finally block to ensure subsequent tests run in float32
						try:
							lowerCAmelCase__       ,lowerCAmelCase__			:		Optional[int]						       =			self.model_tester.prepare_config_and_inputs_for_common()
							for model_class in self.all_model_classes[:2]:
								lowerCAmelCase__			:		Any						       =			self._prepare_for_class(lowercase_     ,lowercase_	)
								lowerCAmelCase__			:		Tuple						       =			model_class(lowercase_	)
								lowerCAmelCase__			:		Optional[int]						       =			model(lowercase_	)

								self.assertIsNotNone(lowercase_	)
						finally:
							tf.keras.mixed_precision.set_global_policy('''float32'''	)







					@slow
					def  __lowerCAmelCase				( self    :       List[str]	):
						lowerCAmelCase__       ,lowerCAmelCase__			:		List[Any]						       =			self.model_tester.prepare_config_and_inputs_for_common()
						# head_mask and decoder_head_mask has different shapes than other input args
						if "head_mask" in inputs_dict:
							del inputs_dict["head_mask"]
						if "decoder_head_mask" in inputs_dict:
							del inputs_dict["decoder_head_mask"]
						if "cross_attn_head_mask" in inputs_dict:
							del inputs_dict["cross_attn_head_mask"]
						lowerCAmelCase__			:		Dict						       =			{
						    module_member
						    for model_class in self.all_model_classes
						    for module in (import_module(model_class.__module__	),)
						    for module_member_name in dir(lowercase_	)
						    if module_member_name.endswith('''MainLayer'''	)
						    for module_member in (getattr(lowercase_     ,lowercase_	),)
						    if isinstance(lowercase_     ,lowercase_	)
						    and tf.keras.layers.Layer in module_member.__bases__
						    and getattr(lowercase_     ,'''_keras_serializable'''     ,lowercase_	)
						}

						for main_layer_class in tf_main_layer_classes:
							# T5MainLayer needs an embed_tokens parameter when called without the inputs_embeds parameter
							if "T5" in main_layer_class.__name__:
								# Take the same values than in TFT5ModelTester for this shared layer
								lowerCAmelCase__			:		List[str]						       =			TFSharedEmbeddings(self.model_tester.vocab_size     ,self.model_tester.hidden_size     ,name='''shared'''	)
								lowerCAmelCase__			:		List[Any]						       =			False
								lowerCAmelCase__			:		List[str]						       =			main_layer_class(lowercase_     ,embed_tokens=lowercase_	)
							else:
								lowerCAmelCase__			:		Optional[Any]						       =			main_layer_class(lowercase_	)

							lowerCAmelCase__			:		Optional[Any]						       =			{
							    name: tf.keras.Input(tensor.shape[1:]     ,dtype=tensor.dtype	) for name, tensor in inputs_dict.items()
							}

							if hasattr(self.model_tester     ,'''num_labels'''	):
								lowerCAmelCase__			:		Dict						       =			self.model_tester.num_labels
							else:
								lowerCAmelCase__			:		List[Any]						       =			2

							lowerCAmelCase__			:		str						       =			tf.data.Dataset.from_tensor_slices(
							    (inputs_dict, np.ones((self.model_tester.batch_size, self.model_tester.seq_length, num_labels, 1)	))	).batch(1	)

							lowerCAmelCase__			:		Tuple						       =			main_layer(lowercase_	)[0]
							lowerCAmelCase__			:		List[Any]						       =			tf.keras.layers.Dense(lowercase_     ,activation='''softmax'''     ,name='''outputs'''	)(lowercase_	)
							lowerCAmelCase__			:		List[Any]						       =			tf.keras.models.Model(inputs=lowercase_     ,outputs=[outputs]	)

							model.compile(loss='''binary_crossentropy'''     ,optimizer='''adam'''     ,metrics=['''binary_accuracy''']	)
							model.fit(lowercase_     ,epochs=1	)

							with tempfile.TemporaryDirectory() as tmpdirname:
								lowerCAmelCase__			:		Optional[int]						       =			os.path.join(lowercase_     ,'''keras_model.h5'''	)
								model.save(lowercase_	)
								if "T5" in main_layer_class.__name__:
									lowerCAmelCase__			:		Any						       =			tf.keras.models.load_model(
									    lowercase_     ,custom_objects={
									        main_layer_class.__name__: main_layer_class,
									        '''TFSharedEmbeddings''': TFSharedEmbeddings,
									    }     ,)
								else:
									lowerCAmelCase__			:		List[Any]						       =			tf.keras.models.load_model(
									    lowercase_     ,custom_objects={main_layer_class.__name__: main_layer_class}	)
								assert isinstance(lowercase_     ,tf.keras.Model	)
								model(lowercase_	)







					@slow
					def  __lowerCAmelCase				( self    :       List[Any]	):
						lowerCAmelCase__       ,lowerCAmelCase__			:		Dict						       =			self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes[:2]:
							lowerCAmelCase__			:		int						       =			model_class(lowercase_	)

							lowerCAmelCase__			:		str						       =			copy.deepcopy(lowercase_	)

							if not self.is_encoder_decoder:
								lowerCAmelCase__			:		Optional[Any]						       =			inputs['''input_ids''']
								del inputs["input_ids"]
							else:
								lowerCAmelCase__			:		Union[str, Any]						       =			inputs['''input_ids''']
								lowerCAmelCase__			:		Any						       =			inputs.get('''decoder_input_ids'''     ,lowercase_	)
								del inputs["input_ids"]
								inputs.pop('''decoder_input_ids'''     ,lowercase_	)

							if not self.is_encoder_decoder:
								lowerCAmelCase__			:		int						       =			model.get_input_embeddings()(lowercase_	)
							else:
								lowerCAmelCase__			:		str						       =			model.get_input_embeddings()(lowercase_	)
								lowerCAmelCase__			:		List[Any]						       =			model.get_input_embeddings()(lowercase_	)

							lowerCAmelCase__			:		Dict						       =			self._prepare_for_class(lowercase_     ,lowercase_	)

							@tf.function
							def run_in_graph_mode():
								return model(lowercase_	)

							lowerCAmelCase__			:		str						       =			run_in_graph_mode()
							self.assertIsNotNone(lowercase_	)







					def  __lowerCAmelCase				( self    :       List[str]     ,lowercase_    :       Tuple     ,lowercase_    :       Optional[Any]	):
						# special tokens cannot be bad tokens
						lowerCAmelCase__			:		List[str]						       =			[]
						if model.config.bos_token_id is not None:
							special_tokens.append(model.config.bos_token_id	)
						if model.config.pad_token_id is not None:
							special_tokens.append(model.config.pad_token_id	)
						if model.config.eos_token_id is not None:
							special_tokens.append(model.config.eos_token_id	)

						# create random bad tokens that are not special tokens
						lowerCAmelCase__			:		Dict						       =			[]
						while len(lowercase_	) < num_bad_tokens:
							lowerCAmelCase__			:		Dict						       =			tf.squeeze(ids_tensor((1, 1)     ,self.model_tester.vocab_size	)     ,0	).numpy()[0]
							if token not in special_tokens:
								bad_tokens.append(lowercase_	)
						return bad_tokens







					def  __lowerCAmelCase				( self    :       Tuple     ,lowercase_    :       List[str]	):
						for token_id in output_ids[0].numpy().tolist():
							self.assertGreaterEqual(lowercase_     ,0	)
							self.assertLess(lowercase_     ,self.model_tester.vocab_size	)







					def  __lowerCAmelCase				( self    :       int     ,lowercase_    :       Union[str, Any]     ,lowercase_    :       Union[str, Any]	):
						# for all bad word tokens
						for bad_word_ids in bad_words_ids:
							# for all slices in batch
							for generated_ids_slice in generated_ids:
								# for all word idx
								for i in range(len(lowercase_	)     ,len(lowercase_	)	):
									# if tokens match
									if generated_ids_slice[i - len(lowercase_	) : i] == bad_word_ids:
										return True
						return False







"""simple docstring"""





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 SwinaSRImageProcessor
							from transformers.image_transforms import get_image_size







class        SCREAMING_SNAKE_CASE      (	unittest.TestCase ):






					"""simple docstring"""



					def __init__( self    :       Dict     ,lowercase_    :       List[str]     ,lowercase_    :       List[str]=7     ,lowercase_    :       List[Any]=3     ,lowercase_    :       str=1_8     ,lowercase_    :       Any=3_0     ,lowercase_    :       int=4_0_0     ,lowercase_    :       Tuple=True     ,lowercase_    :       Optional[int]=1 / 2_5_5     ,lowercase_    :       int=True     ,lowercase_    :       Union[str, Any]=8     ,):
						lowerCAmelCase__			:		Tuple						       =			parent
						lowerCAmelCase__			:		Optional[Any]						       =			batch_size
						lowerCAmelCase__			:		int						       =			num_channels
						lowerCAmelCase__			:		Union[str, Any]						       =			image_size
						lowerCAmelCase__			:		Optional[Any]						       =			min_resolution
						lowerCAmelCase__			:		Union[str, Any]						       =			max_resolution
						lowerCAmelCase__			:		int						       =			do_rescale
						lowerCAmelCase__			:		Tuple						       =			rescale_factor
						lowerCAmelCase__			:		Dict						       =			do_pad
						lowerCAmelCase__			:		str						       =			pad_size







					def  __lowerCAmelCase				( self    :       int	):
						return {
						    "do_rescale": self.do_rescale,
						    "rescale_factor": self.rescale_factor,
						    "do_pad": self.do_pad,
						    "pad_size": self.pad_size,
						}







					def  __lowerCAmelCase				( self    :       Union[str, Any]     ,lowercase_    :       List[str]=False     ,lowercase_    :       Any=False     ,lowercase_    :       Dict=False	):
						assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

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

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

						if torchify:
							lowerCAmelCase__			:		int						       =			[torch.from_numpy(lowercase_	) for x in image_inputs]

						return image_inputs







@require_torch
@require_vision
class        SCREAMING_SNAKE_CASE      (	a_					,							unittest.TestCase ):






					"""simple docstring"""



					lowercase__       				= SwinaSRImageProcessor if is_vision_available() else None







					def  __lowerCAmelCase				( self    :       Dict	):
						lowerCAmelCase__			:		Dict						       =			SwinaSRImageProcessingTester(self	)







					@property
					def  __lowerCAmelCase				( self    :       str	):
						return self.image_processor_tester.prepare_image_processor_dict()







					def  __lowerCAmelCase				( self    :       List[str]	):
						lowerCAmelCase__			:		Any						       =			self.image_processing_class(**self.image_processor_dict	)
						self.assertTrue(hasattr(lowercase_     ,'''do_rescale'''	)	)
						self.assertTrue(hasattr(lowercase_     ,'''rescale_factor'''	)	)
						self.assertTrue(hasattr(lowercase_     ,'''do_pad'''	)	)
						self.assertTrue(hasattr(lowercase_     ,'''pad_size'''	)	)







					def  __lowerCAmelCase				( self    :       Dict	):
						pass







					def  __lowerCAmelCase				( self    :       List[str]     ,lowercase_    :       Optional[Any]	):
						lowerCAmelCase__       ,lowerCAmelCase__			:		Tuple						       =			get_image_size(lowercase_	)
						lowerCAmelCase__			:		Dict						       =			self.image_processor_tester.pad_size

						lowerCAmelCase__			:		List[Any]						       =			(old_height // size + 1) * size - old_height
						lowerCAmelCase__			:		Union[str, Any]						       =			(old_width // size + 1) * size - old_width
						return old_height + pad_height, old_width + pad_width







					def  __lowerCAmelCase				( self    :       List[Any]	):
						# Initialize image_processor
						lowerCAmelCase__			:		str						       =			self.image_processing_class(**self.image_processor_dict	)
						# create random PIL images
						lowerCAmelCase__			:		int						       =			self.image_processor_tester.prepare_inputs(equal_resolution=lowercase_	)
						for image in image_inputs:
							self.assertIsInstance(lowercase_     ,Image.Image	)

						# Test not batched input
						lowerCAmelCase__			:		List[str]						       =			image_processor(image_inputs[0]     ,return_tensors='''pt'''	).pixel_values
						lowerCAmelCase__       ,lowerCAmelCase__			:		List[Any]						       =			self.calculate_expected_size(np.array(image_inputs[0]	)	)
						self.assertEqual(
						    encoded_images.shape     ,(
						        1,
						        self.image_processor_tester.num_channels,
						        expected_height,
						        expected_width,
						    )     ,)







					def  __lowerCAmelCase				( self    :       int	):
						# Initialize image_processor
						lowerCAmelCase__			:		str						       =			self.image_processing_class(**self.image_processor_dict	)
						# create random numpy tensors
						lowerCAmelCase__			:		Tuple						       =			self.image_processor_tester.prepare_inputs(equal_resolution=lowercase_     ,numpify=lowercase_	)
						for image in image_inputs:
							self.assertIsInstance(lowercase_     ,np.ndarray	)

						# Test not batched input
						lowerCAmelCase__			:		Optional[Any]						       =			image_processor(image_inputs[0]     ,return_tensors='''pt'''	).pixel_values
						lowerCAmelCase__       ,lowerCAmelCase__			:		List[Any]						       =			self.calculate_expected_size(image_inputs[0]	)
						self.assertEqual(
						    encoded_images.shape     ,(
						        1,
						        self.image_processor_tester.num_channels,
						        expected_height,
						        expected_width,
						    )     ,)







					def  __lowerCAmelCase				( self    :       Dict	):
						# Initialize image_processor
						lowerCAmelCase__			:		Tuple						       =			self.image_processing_class(**self.image_processor_dict	)
						# create random PyTorch tensors
						lowerCAmelCase__			:		Union[str, Any]						       =			self.image_processor_tester.prepare_inputs(equal_resolution=lowercase_     ,torchify=lowercase_	)
						for image in image_inputs:
							self.assertIsInstance(lowercase_     ,torch.Tensor	)

						# Test not batched input
						lowerCAmelCase__			:		Tuple						       =			image_processor(image_inputs[0]     ,return_tensors='''pt'''	).pixel_values
						lowerCAmelCase__       ,lowerCAmelCase__			:		int						       =			self.calculate_expected_size(image_inputs[0]	)
						self.assertEqual(
						    encoded_images.shape     ,(
						        1,
						        self.image_processor_tester.num_channels,
						        expected_height,
						        expected_width,
						    )     ,)




