

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



      def __init__(     self :							Tuple     ,   A__ :							Union[str, Any]     ,   A__ :							str=13     ,   A__ :							Tuple=32     ,   A__ :							List[Any]=1     ,   A__ :							Any=3     ,   A__ :							int=16     ,   A__ :							Any=[1, 2, 1]     ,   A__ :							Union[str, Any]=[2, 2, 4]     ,   A__ :							Optional[int]=2     ,   A__ :							Tuple=2.0     ,   A__ :							Optional[Any]=True     ,   A__ :							str=0.0     ,   A__ :							List[str]=0.0     ,   A__ :							Dict=0.1     ,   A__ :							Optional[Any]="gelu"     ,   A__ :							Any=False     ,   A__ :							Optional[Any]=True     ,   A__ :							Optional[Any]=0.02     ,   A__ :							List[str]=1e-5     ,   A__ :							Optional[Any]=True     ,   A__ :							Dict=None     ,   A__ :							Dict=False     ,   A__ :							Dict=2     ,   )       ->	Any:
        _snake_case		=				parent
        _snake_case		=				batch_size
        _snake_case		=				image_size
        _snake_case		=				patch_size
        _snake_case		=				num_channels
        _snake_case		=				embed_dim
        _snake_case		=				depths
        _snake_case		=				num_heads
        _snake_case		=				window_size
        _snake_case		=				mlp_ratio
        _snake_case		=				qkv_bias
        _snake_case		=				hidden_dropout_prob
        _snake_case		=				attention_probs_dropout_prob
        _snake_case		=				drop_path_rate
        _snake_case		=				hidden_act
        _snake_case		=				use_absolute_embeddings
        _snake_case		=				patch_norm
        _snake_case		=				layer_norm_eps
        _snake_case		=				initializer_range
        _snake_case		=				is_training
        _snake_case		=				scope
        _snake_case		=				use_labels
        _snake_case		=				upscale

        # here we set some attributes to make tests pass
        _snake_case		=				len(A__						)
        _snake_case		=				embed_dim
        _snake_case		=				(image_size // patch_size) ** 2



      def 		UpperCamelCase_						(     self :							Tuple						)       ->	Dict:
        _snake_case		=				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

        _snake_case		=				None
        if self.use_labels:
          _snake_case		=				ids_tensor([self.batch_size]     ,   self.type_sequence_label_size						)

        _snake_case		=				self.get_config()

        return config, pixel_values, labels



      def 		UpperCamelCase_						(     self :							Union[str, Any]						)       ->	Optional[int]:
        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 		UpperCamelCase_						(     self :							Optional[Any]     ,   A__ :							str     ,   A__ :							List[str]     ,   A__ :							List[Any]						)       ->	List[str]:
        _snake_case		=				SwinaSRModel(config=A__						)
        model.to(A__						)
        model.eval()
        _snake_case		=				model(A__						)

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



      def 		UpperCamelCase_						(     self :							int     ,   A__ :							List[str]     ,   A__ :							Optional[Any]     ,   A__ :							str						)       ->	Any:
        _snake_case		=				SwinaSRForImageSuperResolution(A__						)
        model.to(A__						)
        model.eval()
        _snake_case		=				model(A__						)

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







      def 		UpperCamelCase_						(     self :							Dict						)       ->	Dict:
        _snake_case		=				self.prepare_config_and_inputs()
        _snake_case,	_snake_case,	_snake_case		=				config_and_inputs
        _snake_case		=				{'''pixel_values''': pixel_values}
        return config, inputs_dict



@require_torch
class     lowercase_       (    __lowercase  ,				__lowercase  ,				unittest.TestCase	):
      UpperCamelCase_     :						str		 =							(SwinaSRModel, SwinaSRForImageSuperResolution) if is_torch_available() else ()
      UpperCamelCase_     :						Optional[Any]		 =							{"feature-extraction": SwinaSRModel} if is_torch_available() else {}

      UpperCamelCase_     :						Dict		 =							False
      UpperCamelCase_     :						Optional[int]		 =							False
      UpperCamelCase_     :						Optional[Any]		 =							False
      UpperCamelCase_     :						Dict		 =							False
      UpperCamelCase_     :						Tuple		 =							False



      def 		UpperCamelCase_						(     self :							str						)       ->	Dict:
        _snake_case		=				SwinaSRModelTester(self						)
        _snake_case		=				ConfigTester(self     ,   config_class=A__     ,   embed_dim=37						)



      def 		UpperCamelCase_						(     self :							Optional[Any]						)       ->	Tuple:
        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 		UpperCamelCase_						(     self :							Union[str, Any]						)       ->	Optional[int]:
        _snake_case		=				self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*A__						)



      def 		UpperCamelCase_						(     self :							Optional[int]						)       ->	Union[str, Any]:
        _snake_case		=				self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_super_resolution(*A__						)



      @unittest.skip(reason='''Got `CUDA error: misaligned address` with PyTorch 2.0.0.'''						)
      def 		UpperCamelCase_						(     self :							List[str]						)       ->	Optional[Any]:
        pass



      @unittest.skip(reason='''Swin2SR does not use inputs_embeds'''						)
      def 		UpperCamelCase_						(     self :							Any						)       ->	Any:
        pass



      @unittest.skip(reason='''Swin2SR does not support training yet'''						)
      def 		UpperCamelCase_						(     self :							int						)       ->	Optional[Any]:
        pass



      @unittest.skip(reason='''Swin2SR does not support training yet'''						)
      def 		UpperCamelCase_						(     self :							str						)       ->	Any:
        pass



      def 		UpperCamelCase_						(     self :							Tuple						)       ->	Tuple:
        _snake_case,	_snake_case		=				self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
          _snake_case		=				model_class(A__						)
          self.assertIsInstance(model.get_input_embeddings()     ,   (nn.Module)						)
          _snake_case		=				model.get_output_embeddings()
          self.assertTrue(x is None or isinstance(A__     ,   nn.Linear						)						)



      def 		UpperCamelCase_						(     self :							List[str]						)       ->	Any:
        _snake_case,	_snake_case		=				self.model_tester.prepare_config_and_inputs_for_common()

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

          _snake_case		=				['''pixel_values''']
          self.assertListEqual(arg_names[:1]     ,   A__						)



      @slow
      def 		UpperCamelCase_						(     self :							List[Any]						)       ->	Any:
        for model_name in SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          _snake_case		=				SwinaSRModel.from_pretrained(A__						)
          self.assertIsNotNone(A__						)



      def 		UpperCamelCase_						(     self :							Union[str, Any]						)       ->	Union[str, Any]:
        _snake_case,	_snake_case		=				self.model_tester.prepare_config_and_inputs_for_common()

        _snake_case		=				_config_zero_init(A__						)
        for model_class in self.all_model_classes:
          _snake_case		=				model_class(config=A__						)
          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 		UpperCamelCase_						(     self :							List[Any]						)       ->	Optional[Any]:
        _snake_case,	_snake_case		=				self.model_tester.prepare_config_and_inputs_for_common()
        _snake_case		=				True

        for model_class in self.all_model_classes:
          _snake_case		=				True
          _snake_case		=				False
          _snake_case		=				True
          _snake_case		=				model_class(A__						)
          model.to(A__						)
          model.eval()
          with torch.no_grad():
            _snake_case		=				model(**self._prepare_for_class(A__     ,   A__						)						)
          _snake_case		=				outputs.attentions
          _snake_case		=				len(self.model_tester.depths						)
          self.assertEqual(len(A__						)     ,   A__						)

          # check that output_attentions also work using config
          del inputs_dict["output_attentions"]
          _snake_case		=				True
          _snake_case		=				config.window_size**2
          _snake_case		=				model_class(A__						)
          model.to(A__						)
          model.eval()
          with torch.no_grad():
            _snake_case		=				model(**self._prepare_for_class(A__     ,   A__						)						)
          _snake_case		=				outputs.attentions
          self.assertEqual(len(A__						)     ,   A__						)

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

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

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

          _snake_case		=				outputs.attentions

          self.assertEqual(len(A__						)     ,   A__						)

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



      def 		UpperCamelCase_						(     self :							Tuple						)       ->	str:
        _snake_case		=				SwinaSRImageProcessor()
        _snake_case		=				SwinaSRForImageSuperResolution.from_pretrained('''caidas/swin2SR-classical-sr-x2-64'''						).to(A__						)

        _snake_case		=				Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''						)
        _snake_case		=				processor(images=A__     ,   return_tensors='''pt'''						).to(A__						)

        # forward pass
        with torch.no_grad():
          _snake_case		=				model(**A__						)

        # verify the logits
        _snake_case		=				torch.Size([1, 3, 976, 1296]						)
        self.assertEqual(outputs.reconstruction.shape     ,   A__						)
        _snake_case		=				torch.tensor(
            [[0.5458, 0.5546, 0.5638], [0.5526, 0.5565, 0.5651], [0.5396, 0.5426, 0.5621]]						).to(A__						)
        self.assertTrue(torch.allclose(outputs.reconstruction[0, 0, :3, :3]     ,   A__     ,   atol=1e-4						)						)




import warnings

from ...utils import logging
from .image_processing_detr import DetrImageProcessor


__A     						=      logging.get_logger(__name__)



class     lowercase_       (    __lowercase	):



      def __init__(     self :							List[str]     ,   *A__ :							Tuple     ,   **A__ :							int						)       ->	None:
        warnings.warn(
            '''The class DetrFeatureExtractor is deprecated and will be removed in version 5 of Transformers.'''
            ''' Please use DetrImageProcessor instead.'''     ,   A__     ,   )
        super().__init__(*A__     ,   **A__						)

