




from typing import Callable






def 					snake_case					(							A			)							->							List[Any]:




	'''simple docstring'''


	def wrapper(A			):
		lowerCamelCase_							:		Optional[int]							   =							function_with_docstring.__doc__
		return target_function

	return wrapper






import inspect
import unittest

from transformers import SwinaSRConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import is_torch_available, is_vision_available

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


if is_torch_available():
							import torch
							from torch import nn

							from transformers import SwinaSRForImageSuperResolution, SwinaSRModel
							from transformers.models.swinasr.modeling_swinasr import SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
							from PIL import Image

							from transformers import SwinaSRImageProcessor


class 				__SCREAMING_SNAKE_CASE							:

					def __init__(				self ,       __lowercase ,       __lowercase=13 ,       __lowercase=32 ,       __lowercase=1 ,       __lowercase=3 ,       __lowercase=16 ,       __lowercase=[1, 2, 1] ,       __lowercase=[2, 2, 4] ,       __lowercase=2 ,       __lowercase=2.0 ,       __lowercase=True ,       __lowercase=0.0 ,       __lowercase=0.0 ,       __lowercase=0.1 ,       __lowercase="gelu" ,       __lowercase=False ,       __lowercase=True ,       __lowercase=0.02 ,       __lowercase=1E-5 ,       __lowercase=True ,       __lowercase=None ,       __lowercase=False ,       __lowercase=2 ,       ):







						'''simple docstring'''




						lowerCamelCase_							:		Optional[int]							   =							parent
						lowerCamelCase_							:		List[str]							   =							batch_size
						lowerCamelCase_							:		Dict							   =							image_size
						lowerCamelCase_							:		Any							   =							patch_size
						lowerCamelCase_							:		Any							   =							num_channels
						lowerCamelCase_							:		str							   =							embed_dim
						lowerCamelCase_							:		Tuple							   =							depths
						lowerCamelCase_							:		Union[str, Any]							   =							num_heads
						lowerCamelCase_							:		int							   =							window_size
						lowerCamelCase_							:		Tuple							   =							mlp_ratio
						lowerCamelCase_							:		int							   =							qkv_bias
						lowerCamelCase_							:		Optional[Any]							   =							hidden_dropout_prob
						lowerCamelCase_							:		Optional[int]							   =							attention_probs_dropout_prob
						lowerCamelCase_							:		Optional[int]							   =							drop_path_rate
						lowerCamelCase_							:		Union[str, Any]							   =							hidden_act
						lowerCamelCase_							:		Optional[Any]							   =							use_absolute_embeddings
						lowerCamelCase_							:		Union[str, Any]							   =							patch_norm
						lowerCamelCase_							:		Tuple							   =							layer_norm_eps
						lowerCamelCase_							:		Dict							   =							initializer_range
						lowerCamelCase_							:		Dict							   =							is_training
						lowerCamelCase_							:		Union[str, Any]							   =							scope
						lowerCamelCase_							:		Optional[Any]							   =							use_labels
						lowerCamelCase_							:		Any							   =							upscale

						# here we set some attributes to make tests pass
						lowerCamelCase_							:		int							   =							len(__lowercase					)
						lowerCamelCase_							:		Optional[int]							   =							embed_dim
						lowerCamelCase_							:		Tuple							   =							(image_size // patch_size) ** 2

					def 	lowercase_							(				self					):







						'''simple docstring'''




						lowerCamelCase_							:		int							   =							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

						lowerCamelCase_							:		List[Any]							   =							None
						if self.use_labels:
							lowerCamelCase_							:		Dict							   =							ids_tensor([self.batch_size] ,       self.type_sequence_label_size					)

						lowerCamelCase_							:		int							   =							self.get_config()

						return config, pixel_values, labels

					def 	lowercase_							(				self					):







						'''simple docstring'''




						return SwinaSRConfig(
						    image_size=self.image_size ,       patch_size=self.patch_size ,       num_channels=self.num_channels ,       embed_dim=self.embed_dim ,       depths=self.depths ,       num_heads=self.num_heads ,       window_size=self.window_size ,       mlp_ratio=self.mlp_ratio ,       qkv_bias=self.qkv_bias ,       hidden_dropout_prob=self.hidden_dropout_prob ,       attention_probs_dropout_prob=self.attention_probs_dropout_prob ,       drop_path_rate=self.drop_path_rate ,       hidden_act=self.hidden_act ,       use_absolute_embeddings=self.use_absolute_embeddings ,       path_norm=self.patch_norm ,       layer_norm_eps=self.layer_norm_eps ,       initializer_range=self.initializer_range ,       upscale=self.upscale ,       )

					def 	lowercase_							(				self ,       __lowercase ,       __lowercase ,       __lowercase					):







						'''simple docstring'''




						lowerCamelCase_							:		Any							   =							SwinaSRModel(config=__lowercase					)
						model.to(__lowercase					)
						model.eval()
						lowerCamelCase_							:		int							   =							model(__lowercase					)

						self.parent.assertEqual(
						    result.last_hidden_state.shape ,       (self.batch_size, self.embed_dim, self.image_size, self.image_size)					)

					def 	lowercase_							(				self ,       __lowercase ,       __lowercase ,       __lowercase					):







						'''simple docstring'''




						lowerCamelCase_							:		Optional[Any]							   =							SwinaSRForImageSuperResolution(__lowercase					)
						model.to(__lowercase					)
						model.eval()
						lowerCamelCase_							:		Any							   =							model(__lowercase					)

						lowerCamelCase_							:		int							   =							self.image_size * self.upscale
						self.parent.assertEqual(
						    result.reconstruction.shape ,       (self.batch_size, self.num_channels, expected_image_size, expected_image_size)					)





					def 	lowercase_							(				self					):







						'''simple docstring'''




						lowerCamelCase_							:		Dict							   =							self.prepare_config_and_inputs()
						lowerCamelCase_   ,			lowerCamelCase_   ,			lowerCamelCase_							:		Union[str, Any]							   =							config_and_inputs
						lowerCamelCase_							:		Any							   =							{'pixel_values': pixel_values}
						return config, inputs_dict


@require_torch
class 				__SCREAMING_SNAKE_CASE							(		lowerCamelCase   ,     lowerCamelCase   ,     unittest.TestCase  ):
					_lowerCamelCase		  = (SwinaSRModel, SwinaSRForImageSuperResolution) if is_torch_available() else ()
					_lowerCamelCase		  = {"""feature-extraction""": SwinaSRModel} if is_torch_available() else {}

					_lowerCamelCase		  = False
					_lowerCamelCase		  = False
					_lowerCamelCase		  = False
					_lowerCamelCase		  = False
					_lowerCamelCase		  = False

					def 	lowercase_							(				self					):







						'''simple docstring'''




						lowerCamelCase_							:		Tuple							   =							SwinaSRModelTester(self					)
						lowerCamelCase_							:		Optional[Any]							   =							ConfigTester(self ,       config_class=__lowercase ,       embed_dim=37					)

					def 	lowercase_							(				self					):







						'''simple docstring'''




						self.config_tester.create_and_test_config_to_json_string()
						self.config_tester.create_and_test_config_to_json_file()
						self.config_tester.create_and_test_config_from_and_save_pretrained()
						self.config_tester.create_and_test_config_with_num_labels()
						self.config_tester.check_config_can_be_init_without_params()
						self.config_tester.check_config_arguments_init()

					def 	lowercase_							(				self					):







						'''simple docstring'''




						lowerCamelCase_							:		Optional[Any]							   =							self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*__lowercase					)

					def 	lowercase_							(				self					):







						'''simple docstring'''




						lowerCamelCase_							:		Union[str, Any]							   =							self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_super_resolution(*__lowercase					)

					@unittest.skip(reason='Got `CUDA error: misaligned address` with PyTorch 2.0.0.'					)
					def 	lowercase_							(				self					):







						'''simple docstring'''




						pass

					@unittest.skip(reason='Swin2SR does not use inputs_embeds'					)
					def 	lowercase_							(				self					):







						'''simple docstring'''




						pass

					@unittest.skip(reason='Swin2SR does not support training yet'					)
					def 	lowercase_							(				self					):







						'''simple docstring'''




						pass

					@unittest.skip(reason='Swin2SR does not support training yet'					)
					def 	lowercase_							(				self					):







						'''simple docstring'''




						pass

					def 	lowercase_							(				self					):







						'''simple docstring'''




						lowerCamelCase_   ,			lowerCamelCase_							:		Dict							   =							self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
							lowerCamelCase_							:		Optional[Any]							   =							model_class(__lowercase					)
							self.assertIsInstance(model.get_input_embeddings() ,       (nn.Module)					)
							lowerCamelCase_							:		Union[str, Any]							   =							model.get_output_embeddings()
							self.assertTrue(x is None or isinstance(__lowercase ,       nn.Linear					)					)

					def 	lowercase_							(				self					):







						'''simple docstring'''




						lowerCamelCase_   ,			lowerCamelCase_							:		Optional[int]							   =							self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
							lowerCamelCase_							:		str							   =							model_class(__lowercase					)
							lowerCamelCase_							:		List[Any]							   =							inspect.signature(model.forward					)
							# signature.parameters is an OrderedDict => so arg_names order is deterministic
							lowerCamelCase_							:		Optional[int]							   =							[*signature.parameters.keys()]

							lowerCamelCase_							:		Tuple							   =							['pixel_values']
							self.assertListEqual(arg_names[:1] ,       __lowercase					)

					@slow
					def 	lowercase_							(				self					):







						'''simple docstring'''




						for model_name in SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							lowerCamelCase_							:		Tuple							   =							SwinaSRModel.from_pretrained(__lowercase					)
							self.assertIsNotNone(__lowercase					)

					def 	lowercase_							(				self					):







						'''simple docstring'''




						lowerCamelCase_   ,			lowerCamelCase_							:		Union[str, Any]							   =							self.model_tester.prepare_config_and_inputs_for_common()

						lowerCamelCase_							:		Optional[Any]							   =							_config_zero_init(__lowercase					)
						for model_class in self.all_model_classes:
							lowerCamelCase_							:		List[str]							   =							model_class(config=__lowercase					)
							for name, param in model.named_parameters():
								if "logit_scale" in name:
									continue
								if param.requires_grad:
									self.assertIn(
									    ((param.data.mean() * 1E9).round() / 1E9).item() ,       [0.0, 1.0] ,       msg=f"Parameter {name} of model {model_class} seems not properly initialized" ,       )





					def 	lowercase_							(				self					):







						'''simple docstring'''




						lowerCamelCase_   ,			lowerCamelCase_							:		Union[str, Any]							   =							self.model_tester.prepare_config_and_inputs_for_common()
						lowerCamelCase_							:		Union[str, Any]							   =							True

						for model_class in self.all_model_classes:
							lowerCamelCase_							:		Dict							   =							True
							lowerCamelCase_							:		Optional[Any]							   =							False
							lowerCamelCase_							:		Optional[Any]							   =							True
							lowerCamelCase_							:		Dict							   =							model_class(__lowercase					)
							model.to(__lowercase					)
							model.eval()
							with torch.no_grad():
								lowerCamelCase_							:		Optional[Any]							   =							model(**self._prepare_for_class(__lowercase ,       __lowercase					)					)
							lowerCamelCase_							:		Optional[int]							   =							outputs.attentions
							lowerCamelCase_							:		Tuple							   =							len(self.model_tester.depths					)
							self.assertEqual(len(__lowercase					) ,       __lowercase					)

							# check that output_attentions also work using config
							del inputs_dict["output_attentions"]
							lowerCamelCase_							:		Any							   =							True
							lowerCamelCase_							:		Optional[int]							   =							config.window_size**2
							lowerCamelCase_							:		str							   =							model_class(__lowercase					)
							model.to(__lowercase					)
							model.eval()
							with torch.no_grad():
								lowerCamelCase_							:		Tuple							   =							model(**self._prepare_for_class(__lowercase ,       __lowercase					)					)
							lowerCamelCase_							:		Dict							   =							outputs.attentions
							self.assertEqual(len(__lowercase					) ,       __lowercase					)

							self.assertListEqual(
							    list(attentions[0].shape[-3:]					) ,       [self.model_tester.num_heads[0], window_size_squared, window_size_squared] ,       )
							lowerCamelCase_							:		str							   =							len(__lowercase					)

							# Check attention is always last and order is fine
							lowerCamelCase_							:		Tuple							   =							True
							lowerCamelCase_							:		List[Any]							   =							True
							lowerCamelCase_							:		Tuple							   =							model_class(__lowercase					)
							model.to(__lowercase					)
							model.eval()
							with torch.no_grad():
								lowerCamelCase_							:		List[str]							   =							model(**self._prepare_for_class(__lowercase ,       __lowercase					)					)

							self.assertEqual(out_len + 1 ,       len(__lowercase					)					)

							lowerCamelCase_							:		str							   =							outputs.attentions

							self.assertEqual(len(__lowercase					) ,       __lowercase					)

							self.assertListEqual(
							    list(self_attentions[0].shape[-3:]					) ,       [self.model_tester.num_heads[0], window_size_squared, window_size_squared] ,       )


@require_vision
@require_torch
@slow
class 				__SCREAMING_SNAKE_CASE							(		unittest.TestCase  ):

					def 	lowercase_							(				self					):







						'''simple docstring'''




						lowerCamelCase_							:		Union[str, Any]							   =							SwinaSRImageProcessor()
						lowerCamelCase_							:		Optional[int]							   =							SwinaSRForImageSuperResolution.from_pretrained('caidas/swin2SR-classical-sr-x2-64'					).to(__lowercase					)

						lowerCamelCase_							:		int							   =							Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'					)
						lowerCamelCase_							:		Optional[int]							   =							processor(images=__lowercase ,       return_tensors='pt'					).to(__lowercase					)

						# forward pass
						with torch.no_grad():
							lowerCamelCase_							:		Optional[int]							   =							model(**__lowercase					)

						# verify the logits
						lowerCamelCase_							:		Dict							   =							torch.Size([1, 3, 976, 1_296]					)
						self.assertEqual(outputs.reconstruction.shape ,       __lowercase					)
						lowerCamelCase_							:		Union[str, Any]							   =							torch.tensor(
						    [[0.54_58, 0.55_46, 0.56_38], [0.55_26, 0.55_65, 0.56_51], [0.53_96, 0.54_26, 0.56_21]]					).to(__lowercase					)
						self.assertTrue(torch.allclose(outputs.reconstruction[0, 0, :3, :3] ,       __lowercase ,       atol=1E-4					)					)
