


import inspect
import tempfile
import unittest

from huggingface_hub import hf_hub_download

from transformers import is_torch_available
from transformers.testing_utils import is_flaky, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


snake_case_    :      Optional[Any]				    =				1e-4

if is_torch_available():
							import torch

							from transformers import AutoformerConfig, AutoformerForPrediction, AutoformerModel
							from transformers.models.autoformer.modeling_autoformer import AutoformerDecoder, AutoformerEncoder

@require_torch
class     A__				:




						def __init__(							self       :   str					,     _a       :   Optional[Any]					,     _a       :   Optional[Any]=16					,     _a       :   int=13					,     _a       :   Optional[int]=7					,     _a       :   int=14					,     _a       :   str=10					,     _a       :   List[Any]=19					,     _a       :   Any=5					,     _a       :   Any=4					,     _a       :   List[str]=True					,     _a       :   Union[str, Any]=16					,     _a       :   Tuple=2					,     _a       :   str=4					,     _a       :   Tuple=4					,     _a       :   int="gelu"					,     _a       :   Any=0.1					,     _a       :   int=0.1					,     _a       :   Optional[int]=[1, 2, 3, 4, 5]					,     _a       :   List[Any]=25					,     _a       :   Union[str, Any]=5					,     )				->  Optional[int]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE      	=d_model
										_SCREAMING_SNAKE_CASE      	=parent
										_SCREAMING_SNAKE_CASE      	=batch_size
										_SCREAMING_SNAKE_CASE      	=prediction_length
										_SCREAMING_SNAKE_CASE      	=context_length
										_SCREAMING_SNAKE_CASE      	=cardinality
										_SCREAMING_SNAKE_CASE      	=num_time_features
										_SCREAMING_SNAKE_CASE      	=lags_sequence
										_SCREAMING_SNAKE_CASE      	=embedding_dimension
										_SCREAMING_SNAKE_CASE      	=is_training
										_SCREAMING_SNAKE_CASE      	=hidden_size
										_SCREAMING_SNAKE_CASE      	=num_hidden_layers
										_SCREAMING_SNAKE_CASE      	=num_attention_heads
										_SCREAMING_SNAKE_CASE      	=intermediate_size
										_SCREAMING_SNAKE_CASE      	=hidden_act
										_SCREAMING_SNAKE_CASE      	=hidden_dropout_prob
										_SCREAMING_SNAKE_CASE      	=attention_probs_dropout_prob

										_SCREAMING_SNAKE_CASE      	=context_length
										_SCREAMING_SNAKE_CASE      	=prediction_length + label_length
										_SCREAMING_SNAKE_CASE      	=label_length

										_SCREAMING_SNAKE_CASE      	=moving_average
										_SCREAMING_SNAKE_CASE      	=autocorrelation_factor




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


										"""simple docstring"""





										return AutoformerConfig(
										    d_model=self.d_model					,     encoder_layers=self.num_hidden_layers					,     decoder_layers=self.num_hidden_layers					,     encoder_attention_heads=self.num_attention_heads					,     decoder_attention_heads=self.num_attention_heads					,     encoder_ffn_dim=self.intermediate_size					,     decoder_ffn_dim=self.intermediate_size					,     dropout=self.hidden_dropout_prob					,     attention_dropout=self.attention_probs_dropout_prob					,     prediction_length=self.prediction_length					,     context_length=self.context_length					,     label_length=self.label_length					,     lags_sequence=self.lags_sequence					,     num_time_features=self.num_time_features					,     num_static_categorical_features=1					,     cardinality=[self.cardinality]					,     embedding_dimension=[self.embedding_dimension]					,     moving_average=self.moving_average					,     )




						def 				__UpperCamelCase					(							self       :   Union[str, Any]					,     _a       :   str	)				->  Tuple:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE      	=config.context_length + max(config.lags_sequence	)

										_SCREAMING_SNAKE_CASE      	=ids_tensor([self.batch_size, 1]					,     config.cardinality[0]	)
										_SCREAMING_SNAKE_CASE      	=floats_tensor([self.batch_size, _past_length, config.num_time_features]	)
										_SCREAMING_SNAKE_CASE      	=floats_tensor([self.batch_size, _past_length]	)
										_SCREAMING_SNAKE_CASE      	=floats_tensor([self.batch_size, _past_length]	) > 0.5

										# decoder inputs
										_SCREAMING_SNAKE_CASE      	=floats_tensor([self.batch_size, config.prediction_length, config.num_time_features]	)
										_SCREAMING_SNAKE_CASE      	=floats_tensor([self.batch_size, config.prediction_length]	)

										_SCREAMING_SNAKE_CASE      	={
										    '''past_values''': past_values,
										    '''static_categorical_features''': static_categorical_features,
										    '''past_time_features''': past_time_features,
										    '''past_observed_mask''': past_observed_mask,
										    '''future_time_features''': future_time_features,
										    '''future_values''': future_values,
										}
										return inputs_dict




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


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE      	=self.get_config()
										_SCREAMING_SNAKE_CASE      	=self.prepare_autoformer_inputs_dict(lowercase_	)
										return config, inputs_dict




						def 				__UpperCamelCase					(							self       :   List[Any]	)				->  List[Any]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE      	=self.prepare_config_and_inputs()
										return config, inputs_dict




						def 				__UpperCamelCase					(							self       :   Dict					,     _a       :   Optional[int]					,     _a       :   Union[str, Any]	)				->  Tuple:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE      	=AutoformerModel(config=lowercase_	).to(lowercase_	).eval()
										_SCREAMING_SNAKE_CASE      	=model(**lowercase_	)

										_SCREAMING_SNAKE_CASE      	=outputs.encoder_last_hidden_state
										_SCREAMING_SNAKE_CASE      	=outputs.last_hidden_state

										with tempfile.TemporaryDirectory() as tmpdirname:
														_SCREAMING_SNAKE_CASE      	=model.get_encoder()
														encoder.save_pretrained(lowercase_	)
														_SCREAMING_SNAKE_CASE      	=AutoformerEncoder.from_pretrained(lowercase_	).to(lowercase_	)

										_SCREAMING_SNAKE_CASE      	=model.create_network_inputs(**lowercase_	)
										_SCREAMING_SNAKE_CASE      	=model.decomposition_layer(transformer_inputs[:, : config.context_length, ...]	)

										_SCREAMING_SNAKE_CASE      	=torch.cat(
										    (transformer_inputs[:, : config.context_length, ...], feature[:, : config.context_length, ...])					,     dim=-1					,     )
										_SCREAMING_SNAKE_CASE      	=encoder(inputs_embeds=lowercase_	)[0]
										self.parent.assertTrue((encoder_last_hidden_state_a - encoder_last_hidden_state).abs().max().item() < 1E-3	)

										_SCREAMING_SNAKE_CASE      	=(
										    torch.mean(transformer_inputs[:, : config.context_length, ...]					,     dim=1	)
										    .unsqueeze(1	)
										    .repeat(1					,     config.prediction_length					,     1	)
										)
										_SCREAMING_SNAKE_CASE      	=torch.zeros(
										    [transformer_inputs.shape[0], config.prediction_length, transformer_inputs.shape[2]]					,     device=enc_input.device					,     )

										_SCREAMING_SNAKE_CASE      	=torch.cat(
										    (
										        torch.cat((seasonal_input[:, -config.label_length :, ...], zeros)					,     dim=1	),
										        feature[:, config.context_length - config.label_length :, ...],
										    )					,     dim=-1					,     )
										_SCREAMING_SNAKE_CASE      	=torch.cat(
										    (
										        torch.cat((trend_input[:, -config.label_length :, ...], mean)					,     dim=1	),
										        feature[:, config.context_length - config.label_length :, ...],
										    )					,     dim=-1					,     )

										with tempfile.TemporaryDirectory() as tmpdirname:
														_SCREAMING_SNAKE_CASE      	=model.get_decoder()
														decoder.save_pretrained(lowercase_	)
														_SCREAMING_SNAKE_CASE      	=AutoformerDecoder.from_pretrained(lowercase_	).to(lowercase_	)

										_SCREAMING_SNAKE_CASE      	=decoder(
										    trend=lowercase_					,     inputs_embeds=lowercase_					,     encoder_hidden_states=lowercase_					,     )[0]

										self.parent.assertTrue((last_hidden_state_a - last_hidden_state).abs().max().item() < 1E-3	)

@require_torch
class     A__				(		a_ ,  a_ ,  unittest.TestCase	):
						UpperCAmelCase   							=    (AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
						UpperCAmelCase   							=    (AutoformerForPrediction,) if is_torch_available() else ()
						UpperCAmelCase   							=    {"feature-extraction": AutoformerModel} if is_torch_available() else {}
						UpperCAmelCase   							=    False
						UpperCAmelCase   							=    False
						UpperCAmelCase   							=    False
						UpperCAmelCase   							=    False
						UpperCAmelCase   							=    False
						UpperCAmelCase   							=    False




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


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE      	=AutoformerModelTester(self	)
										_SCREAMING_SNAKE_CASE      	=ConfigTester(self					,     config_class=lowercase_					,     has_text_modality=lowercase_	)




						def 				__UpperCamelCase					(							self       :   Optional[Any]	)				->  Dict:


										"""simple docstring"""





										self.config_tester.run_common_tests()




						def 				__UpperCamelCase					(							self       :   str	)				->  Optional[Any]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE      	=self.model_tester.prepare_config_and_inputs()
										for model_class in self.all_model_classes:
														_SCREAMING_SNAKE_CASE      	=model_class(lowercase_	)

														with tempfile.TemporaryDirectory() as tmpdirname:
																		model.save_pretrained(lowercase_	)
																		_SCREAMING_SNAKE_CASE      	=model_class.from_pretrained(lowercase_					,     output_loading_info=lowercase_	)
														self.assertEqual(info['''missing_keys''']					,     []	)




						def 				__UpperCamelCase					(							self       :   List[Any]	)				->  List[str]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE      	=self.model_tester.prepare_config_and_inputs_for_common()
										self.model_tester.check_encoder_decoder_model_standalone(*lowercase_	)




						@unittest.skip(reason='''Model has no tokens embeddings'''	)
						def 				__UpperCamelCase					(							self       :   Optional[int]	)				->  str:


										"""simple docstring"""





										pass




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


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE      	=inspect.signature(getattr(lowercase_					,     '''forward'''	)	)
										# The main input is the name of the argument after `self`
										_SCREAMING_SNAKE_CASE      	=list(model_signature.parameters.keys()	)[1]
										self.assertEqual(AutoformerModel.main_input_name					,     lowercase_	)




						def 				__UpperCamelCase					(							self       :   Union[str, Any]	)				->  List[Any]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE      	=self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
														_SCREAMING_SNAKE_CASE      	=model_class(lowercase_	)
														_SCREAMING_SNAKE_CASE      	=inspect.signature(model.forward	)
														# signature.parameters is an OrderedDict => so arg_names order is deterministic
														_SCREAMING_SNAKE_CASE      	=[*signature.parameters.keys()]

														_SCREAMING_SNAKE_CASE      	=[
														    '''past_values''',
														    '''past_time_features''',
														    '''past_observed_mask''',
														    '''static_categorical_features''',
														    '''static_real_features''',
														    '''future_values''',
														    '''future_time_features''',
														]

														if model.__class__.__name__ in ["AutoformerForPrediction"]:
																		expected_arg_names.append('''future_observed_mask'''	)

														expected_arg_names.extend(
														    [
														        '''decoder_attention_mask''',
														        '''head_mask''',
														        '''decoder_head_mask''',
														        '''cross_attn_head_mask''',
														        '''encoder_outputs''',
														        '''past_key_values''',
														        '''output_hidden_states''',
														        '''output_attentions''',
														        '''use_cache''',
														        '''return_dict''',
														    ]	)

														self.assertListEqual(arg_names[: len(lowercase_	)]					,     lowercase_	)




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


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE      	=self.model_tester.prepare_config_and_inputs_for_common()
										_SCREAMING_SNAKE_CASE      	=True

										_SCREAMING_SNAKE_CASE      	=getattr(self.model_tester					,     '''seq_length'''					,     lowercase_	)
										_SCREAMING_SNAKE_CASE      	=getattr(self.model_tester					,     '''decoder_seq_length'''					,     lowercase_	)
										_SCREAMING_SNAKE_CASE      	=getattr(self.model_tester					,     '''encoder_seq_length'''					,     lowercase_	)
										_SCREAMING_SNAKE_CASE      	=getattr(self.model_tester					,     '''d_model'''					,     lowercase_	)
										_SCREAMING_SNAKE_CASE      	=getattr(self.model_tester					,     '''num_attention_heads'''					,     lowercase_	)
										_SCREAMING_SNAKE_CASE      	=d_model // num_attention_heads

										for model_class in self.all_model_classes:
														_SCREAMING_SNAKE_CASE      	=True
														_SCREAMING_SNAKE_CASE      	=False
														_SCREAMING_SNAKE_CASE      	=True
														_SCREAMING_SNAKE_CASE      	=model_class(lowercase_	)
														model.to(lowercase_	)
														model.eval()
														with torch.no_grad():
																		_SCREAMING_SNAKE_CASE      	=model(**self._prepare_for_class(lowercase_					,     lowercase_	)	)
														_SCREAMING_SNAKE_CASE      	=outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
														self.assertEqual(len(lowercase_	)					,     self.model_tester.num_hidden_layers	)

														# check that output_attentions also work using config
														del inputs_dict["output_attentions"]
														_SCREAMING_SNAKE_CASE      	=True
														_SCREAMING_SNAKE_CASE      	=model_class(lowercase_	)
														model.to(lowercase_	)
														model.eval()
														with torch.no_grad():
																		_SCREAMING_SNAKE_CASE      	=model(**self._prepare_for_class(lowercase_					,     lowercase_	)	)
														_SCREAMING_SNAKE_CASE      	=outputs.encoder_attentions
														self.assertEqual(len(lowercase_	)					,     self.model_tester.num_hidden_layers	)

														self.assertListEqual(
														    list(attentions[0].shape[-3:]	)					,     [self.model_tester.num_attention_heads, encoder_seq_length, dim]					,     )
														_SCREAMING_SNAKE_CASE      	=len(lowercase_	)

														_SCREAMING_SNAKE_CASE      	=7

														if "last_hidden_state" in outputs:
																		correct_outlen += 1

														if "trend" in outputs:
																		correct_outlen += 1

														if "past_key_values" in outputs:
																		correct_outlen += 1  # past_key_values have been returned

														if "loss" in outputs:
																		correct_outlen += 1

														if "params" in outputs:
																		correct_outlen += 1

														self.assertEqual(lowercase_					,     lowercase_	)

														# decoder attentions
														_SCREAMING_SNAKE_CASE      	=outputs.decoder_attentions
														self.assertIsInstance(lowercase_					,     (list, tuple)	)
														self.assertEqual(len(lowercase_	)					,     self.model_tester.num_hidden_layers	)
														self.assertListEqual(
														    list(decoder_attentions[0].shape[-3:]	)					,     [self.model_tester.num_attention_heads, decoder_seq_length, dim]					,     )

														# cross attentions
														_SCREAMING_SNAKE_CASE      	=outputs.cross_attentions
														self.assertIsInstance(lowercase_					,     (list, tuple)	)
														self.assertEqual(len(lowercase_	)					,     self.model_tester.num_hidden_layers	)
														self.assertListEqual(
														    list(cross_attentions[0].shape[-3:]	)					,     [self.model_tester.num_attention_heads, decoder_seq_length, dim]					,     )

										# Check attention is always last and order is fine
										_SCREAMING_SNAKE_CASE      	=True
										_SCREAMING_SNAKE_CASE      	=True
										_SCREAMING_SNAKE_CASE      	=model_class(lowercase_	)
										model.to(lowercase_	)
										model.eval()
										with torch.no_grad():
														_SCREAMING_SNAKE_CASE      	=model(**self._prepare_for_class(lowercase_					,     lowercase_	)	)

										self.assertEqual(out_len + 2					,     len(lowercase_	)	)

										_SCREAMING_SNAKE_CASE      	=outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions

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




						@is_flaky()
						def 				__UpperCamelCase					(							self       :   str	)				->  List[Any]:


										"""simple docstring"""





										super().test_retain_grad_hidden_states_attentions()







def     lowerCamelCase( a__="train-batch.pt"):
				_SCREAMING_SNAKE_CASE      	=hf_hub_download(repo_id='''hf-internal-testing/tourism-monthly-batch'''						,filename=A_						,repo_type='''dataset''')
				_SCREAMING_SNAKE_CASE      	=torch.load(A_						,map_location=A_)
				return batch


@require_torch
@slow
class     A__				(		unittest.TestCase	):




						def 				__UpperCamelCase					(							self       :   int	)				->  str:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE      	=AutoformerModel.from_pretrained('''huggingface/autoformer-tourism-monthly'''	).to(lowercase_	)
										_SCREAMING_SNAKE_CASE      	=prepare_batch()

										with torch.no_grad():
														_SCREAMING_SNAKE_CASE      	=model(
														    past_values=batch['''past_values''']					,     past_time_features=batch['''past_time_features''']					,     past_observed_mask=batch['''past_observed_mask''']					,     static_categorical_features=batch['''static_categorical_features''']					,     future_values=batch['''future_values''']					,     future_time_features=batch['''future_time_features''']					,     )[0]

										_SCREAMING_SNAKE_CASE      	=torch.Size(
										    (64, model.config.prediction_length + model.config.label_length, model.config.feature_size)	)
										self.assertEqual(output.shape					,     lowercase_	)

										_SCREAMING_SNAKE_CASE      	=torch.tensor(
										    [[0.35_93, -1.33_98, 0.63_30], [0.22_79, 1.53_96, -0.17_92], [0.04_50, 1.32_25, -0.23_35]]					,     device=lowercase_	)
										self.assertTrue(torch.allclose(output[0, :3, :3]					,     lowercase_					,     atol=lowercase_	)	)




						def 				__UpperCamelCase					(							self       :   Dict	)				->  Dict:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE      	=AutoformerForPrediction.from_pretrained('''huggingface/autoformer-tourism-monthly'''	).to(lowercase_	)
										_SCREAMING_SNAKE_CASE      	=prepare_batch('''val-batch.pt'''	)
										with torch.no_grad():
														_SCREAMING_SNAKE_CASE      	=model(
														    past_values=batch['''past_values''']					,     past_time_features=batch['''past_time_features''']					,     past_observed_mask=batch['''past_observed_mask''']					,     static_categorical_features=batch['''static_categorical_features''']					,     ).encoder_last_hidden_state
										_SCREAMING_SNAKE_CASE      	=torch.Size((64, model.config.context_length, model.config.d_model)	)
										self.assertEqual(output.shape					,     lowercase_	)

										_SCREAMING_SNAKE_CASE      	=torch.tensor(
										    [[-0.07_34, -0.90_36, 0.83_58], [4.71_86, 2.41_13, 1.95_81], [1.79_53, 2.35_58, 1.29_70]]					,     device=lowercase_	)
										self.assertTrue(torch.allclose(output[0, :3, :3]					,     lowercase_					,     atol=lowercase_	)	)




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


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE      	=AutoformerForPrediction.from_pretrained('''huggingface/autoformer-tourism-monthly'''	).to(lowercase_	)
										_SCREAMING_SNAKE_CASE      	=prepare_batch('''val-batch.pt'''	)
										with torch.no_grad():
														_SCREAMING_SNAKE_CASE      	=model.generate(
														    static_categorical_features=batch['''static_categorical_features''']					,     past_time_features=batch['''past_time_features''']					,     past_values=batch['''past_values''']					,     future_time_features=batch['''future_time_features''']					,     past_observed_mask=batch['''past_observed_mask''']					,     )
										_SCREAMING_SNAKE_CASE      	=torch.Size((64, model.config.num_parallel_samples, model.config.prediction_length)	)
										self.assertEqual(outputs.sequences.shape					,     lowercase_	)

										_SCREAMING_SNAKE_CASE      	=torch.tensor([31_30.67_63, 40_56.52_93, 70_53.07_86]					,     device=lowercase_	)
										_SCREAMING_SNAKE_CASE      	=outputs.sequences.mean(dim=1	)
										self.assertTrue(torch.allclose(mean_prediction[0, -3:]					,     lowercase_					,     rtol=1E-1	)	)


"""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, prepare_image_inputs


if is_torch_available():
							import torch

if is_vision_available():
							from PIL import Image

							from transformers import LevitImageProcessor







class 							SCREAMING_SNAKE_CASE   (						unittest.TestCase			):






					"""simple docstring"""



					def __init__(			self     :							Any  ,lowercase_     :							Dict  ,lowercase_     :							List[str]=7  ,lowercase_     :							Tuple=3  ,lowercase_     :							List[str]=1_8  ,lowercase_     :							Optional[Any]=3_0  ,lowercase_     :							List[Any]=4_0_0  ,lowercase_     :							List[Any]=True  ,lowercase_     :							Any=None  ,lowercase_     :							Optional[Any]=True  ,lowercase_     :							str=None  ,lowercase_     :							List[Any]=True  ,lowercase_     :							Dict=[0.5, 0.5, 0.5]  ,lowercase_     :							Dict=[0.5, 0.5, 0.5]  ,):
						lowerCAmelCase__      :		Any    							=      size if size is not None else {'''shortest_edge''': 1_8}
						lowerCAmelCase__      :		Union[str, Any]    							=      crop_size if crop_size is not None else {'''height''': 1_8, '''width''': 1_8}
						lowerCAmelCase__      :		Dict    							=      parent
						lowerCAmelCase__      :		Dict    							=      batch_size
						lowerCAmelCase__      :		List[str]    							=      num_channels
						lowerCAmelCase__      :		Any    							=      image_size
						lowerCAmelCase__      :		Union[str, Any]    							=      min_resolution
						lowerCAmelCase__      :		Dict    							=      max_resolution
						lowerCAmelCase__      :		List[str]    							=      do_resize
						lowerCAmelCase__      :		Optional[Any]    							=      size
						lowerCAmelCase__      :		Tuple    							=      do_center_crop
						lowerCAmelCase__      :		Optional[int]    							=      crop_size
						lowerCAmelCase__      :		List[str]    							=      do_normalize
						lowerCAmelCase__      :		Tuple    							=      image_mean
						lowerCAmelCase__      :		int    							=      image_std







					def 			__lowerCAmelCase					(			self     :							List[str]						):
						return {
						    "image_mean": self.image_mean,
						    "image_std": self.image_std,
						    "do_normalize": self.do_normalize,
						    "do_resize": self.do_resize,
						    "do_center_crop": self.do_center_crop,
						    "size": self.size,
						    "crop_size": self.crop_size,
						}







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






					"""simple docstring"""



					lowercase__												=			LevitImageProcessor if is_vision_available() else None







					def 			__lowerCAmelCase					(			self     :							List[str]						):
						lowerCAmelCase__      :		Optional[Any]    							=      LevitImageProcessingTester(self						)







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







					def 			__lowerCAmelCase					(			self     :							str						):
						lowerCAmelCase__      :		Optional[int]    							=      self.image_processing_class(**self.image_processor_dict						)
						self.assertTrue(hasattr(lowercase_  ,'''image_mean'''						)						)
						self.assertTrue(hasattr(lowercase_  ,'''image_std'''						)						)
						self.assertTrue(hasattr(lowercase_  ,'''do_normalize'''						)						)
						self.assertTrue(hasattr(lowercase_  ,'''do_resize'''						)						)
						self.assertTrue(hasattr(lowercase_  ,'''do_center_crop'''						)						)
						self.assertTrue(hasattr(lowercase_  ,'''size'''						)						)







					def 			__lowerCAmelCase					(			self     :							Any						):
						lowerCAmelCase__      :		int    							=      self.image_processing_class.from_dict(self.image_processor_dict						)
						self.assertEqual(image_processor.size  ,{'''shortest_edge''': 1_8}						)
						self.assertEqual(image_processor.crop_size  ,{'''height''': 1_8, '''width''': 1_8}						)

						lowerCAmelCase__      :		List[str]    							=      self.image_processing_class.from_dict(self.image_processor_dict  ,size=4_2  ,crop_size=8_4						)
						self.assertEqual(image_processor.size  ,{'''shortest_edge''': 4_2}						)
						self.assertEqual(image_processor.crop_size  ,{'''height''': 8_4, '''width''': 8_4}						)







					def 			__lowerCAmelCase					(			self     :							Union[str, Any]						):
						pass







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

						# Test not batched input
						lowerCAmelCase__      :		Any    							=      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
						lowerCAmelCase__      :		Optional[int]    							=      image_processing(lowercase_  ,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 			__lowerCAmelCase					(			self     :							Union[str, Any]						):
						# Initialize image_processing
						lowerCAmelCase__      :		str    							=      self.image_processing_class(**self.image_processor_dict						)
						# create random numpy tensors
						lowerCAmelCase__      :		Optional[Any]    							=      prepare_image_inputs(self.image_processor_tester  ,equal_resolution=lowercase_  ,numpify=lowercase_						)
						for image in image_inputs:
							self.assertIsInstance(lowercase_  ,np.ndarray						)

						# Test not batched input
						lowerCAmelCase__      :		Tuple    							=      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
						lowerCAmelCase__      :		Union[str, Any]    							=      image_processing(lowercase_  ,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 			__lowerCAmelCase					(			self     :							int						):
						# Initialize image_processing
						lowerCAmelCase__      :		Tuple    							=      self.image_processing_class(**self.image_processor_dict						)
						# create random PyTorch tensors
						lowerCAmelCase__      :		Dict    							=      prepare_image_inputs(self.image_processor_tester  ,equal_resolution=lowercase_  ,torchify=lowercase_						)
						for image in image_inputs:
							self.assertIsInstance(lowercase_  ,torch.Tensor						)

						# Test not batched input
						lowerCAmelCase__      :		Dict    							=      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
						lowerCAmelCase__      :		Optional[int]    							=      image_processing(lowercase_  ,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'''],
						    )  ,)




