'''simple docstring'''





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    UpperCamelCase :







    """simple docstring"""





    def __init__( self			:		Union[str, Any]				,				UpperCAmelCase_			:		int				,				UpperCAmelCase_			:		Union[str, Any]=1_3				,				UpperCAmelCase_			:		Optional[Any]=3_2				,				UpperCAmelCase_			:		str=1				,				UpperCAmelCase_			:		Tuple=3				,				UpperCAmelCase_			:		Any=1_6				,				UpperCAmelCase_			:		List[Any]=[1, 2, 1]				,				UpperCAmelCase_			:		Union[str, Any]=[2, 2, 4]				,				UpperCAmelCase_			:		int=2				,				UpperCAmelCase_			:		Optional[Any]=2.0				,				UpperCAmelCase_			:		str=True				,				UpperCAmelCase_			:		Union[str, Any]=0.0				,				UpperCAmelCase_			:		int=0.0				,				UpperCAmelCase_			:		Tuple=0.1				,				UpperCAmelCase_			:		Optional[int]="gelu"				,				UpperCAmelCase_			:		Optional[Any]=False				,				UpperCAmelCase_			:		Optional[int]=True				,				UpperCAmelCase_			:		Optional[Any]=0.02				,				UpperCAmelCase_			:		Dict=1e-5				,				UpperCAmelCase_			:		List[str]=True				,				UpperCAmelCase_			:		Any=None				,				UpperCAmelCase_			:		Tuple=False				,				UpperCAmelCase_			:		Optional[Any]=2				,				):


         """simple docstring"""







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

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





    def 					SCREAMING_SNAKE_CASE_			( self			:		int):


         """simple docstring"""







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

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

         a :				int				=      self.get_config()

         return config, pixel_values, labels





    def 					SCREAMING_SNAKE_CASE_			( self			:		Union[str, Any]):


         """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 					SCREAMING_SNAKE_CASE_			( self			:		str				,				UpperCAmelCase_			:		Union[str, Any]				,				UpperCAmelCase_			:		Tuple				,				UpperCAmelCase_			:		Optional[int]):


         """simple docstring"""







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

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





    def 					SCREAMING_SNAKE_CASE_			( self			:		Tuple				,				UpperCAmelCase_			:		Dict				,				UpperCAmelCase_			:		Tuple				,				UpperCAmelCase_			:		List[str]):


         """simple docstring"""







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

         a :				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 					SCREAMING_SNAKE_CASE_			( self			:		Optional[int]):


         """simple docstring"""







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






@require_torch
class    UpperCamelCase (    a_  ,			a_  ,			unittest.TestCase    ):







    """simple docstring"""





    A			:  Optional[Any]            =       (SwinaSRModel, SwinaSRForImageSuperResolution) if is_torch_available() else ()
    A			:  Union[str, Any]            =       {"feature-extraction": SwinaSRModel} if is_torch_available() else {}

    A			:  Optional[int]            =       False
    A			:  Dict            =       False
    A			:  Any            =       False
    A			:  Optional[Any]            =       False
    A			:  List[str]            =       False





    def 					SCREAMING_SNAKE_CASE_			( self			:		Union[str, Any]):


         """simple docstring"""







         a :				Tuple				=      SwinaSRModelTester(self)
         a :				Optional[Any]				=      ConfigTester(self				,				config_class=__lowercase				,				embed_dim=3_7)





    def 					SCREAMING_SNAKE_CASE_			( self			:		Optional[int]):


         """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 					SCREAMING_SNAKE_CASE_			( self			:		Any):


         """simple docstring"""







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





    def 					SCREAMING_SNAKE_CASE_			( self			:		Tuple):


         """simple docstring"""







         a :				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 					SCREAMING_SNAKE_CASE_			( self			:		Any):


         """simple docstring"""







         pass





    @unittest.skip(reason='Swin2SR does not use inputs_embeds')
    def 					SCREAMING_SNAKE_CASE_			( self			:		Optional[int]):


         """simple docstring"""







         pass





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


         """simple docstring"""







         pass





    @unittest.skip(reason='Swin2SR does not support training yet')
    def 					SCREAMING_SNAKE_CASE_			( self			:		Optional[Any]):


         """simple docstring"""







         pass





    def 					SCREAMING_SNAKE_CASE_			( self			:		List[Any]):


         """simple docstring"""







         a :				Dict				=      self.model_tester.prepare_config_and_inputs_for_common()

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





    def 					SCREAMING_SNAKE_CASE_			( self			:		List[str]):


         """simple docstring"""







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

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

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





    @slow
    def 					SCREAMING_SNAKE_CASE_			( self			:		Union[str, Any]):


         """simple docstring"""







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





    def 					SCREAMING_SNAKE_CASE_			( self			:		Optional[Any]):


         """simple docstring"""







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

         a :				Optional[Any]				=      _config_zero_init(__lowercase)
         for model_class in self.all_model_classes:
              a :				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 					SCREAMING_SNAKE_CASE_			( self			:		Tuple):


         """simple docstring"""







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

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

              # check that output_attentions also work using config
              del inputs_dict["output_attentions"]
              a :				Any				=      True
              a :				Optional[int]				=      config.window_size**2
              a :				str				=      model_class(__lowercase)
              model.to(__lowercase)
              model.eval()
              with torch.no_grad():
                   a :				Tuple				=      model(**self._prepare_for_class(__lowercase				,				__lowercase))
              a :				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]				,				)
              a :				str				=      len(__lowercase)

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

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

              a :				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    UpperCamelCase (    unittest.TestCase    ):







    """simple docstring"""





    def 					SCREAMING_SNAKE_CASE_			( self			:		Union[str, Any]):


         """simple docstring"""







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

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

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

         # verify the logits
         a :				Dict				=      torch.Size([1, 3, 9_7_6, 1_2_9_6])
         self.assertEqual(outputs.reconstruction.shape				,				__lowercase)
         a :				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))







def 					snake_case					(							A			)							->							int:




	'''simple docstring'''


	if not isinstance(A						,   A			):
		raise ValueError('double_factorial() only accepts integral values'			)
	if n < 0:
		raise ValueError('double_factorial() not defined for negative values'			)
	return 1 if n <= 1 else n * double_factorial(n - 2			)


if __name__ == "__main__":
							import doctest

							doctest.testmod()
