

"""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 		_A							:





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

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





      def        _lowerCamelCase	(	self		) ->       str:
         lowerCamelCase__						       =      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

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

         lowerCamelCase__						       =      self.get_config()

         return config, pixel_values, labels





      def        _lowerCamelCase	(	self		) ->       Optional[Any]:
         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        _lowerCamelCase	(	self     ,    SCREAMING_SNAKE_CASE__     ,    SCREAMING_SNAKE_CASE__     ,    SCREAMING_SNAKE_CASE__		) ->       int:
         lowerCamelCase__						       =      SwinaSRModel(config=SCREAMING_SNAKE_CASE__		)
         model.to(SCREAMING_SNAKE_CASE__		)
         model.eval()
         lowerCamelCase__						       =      model(SCREAMING_SNAKE_CASE__		)

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





      def        _lowerCamelCase	(	self     ,    SCREAMING_SNAKE_CASE__     ,    SCREAMING_SNAKE_CASE__     ,    SCREAMING_SNAKE_CASE__		) ->       str:
         lowerCamelCase__						       =      SwinaSRForImageSuperResolution(SCREAMING_SNAKE_CASE__		)
         model.to(SCREAMING_SNAKE_CASE__		)
         model.eval()
         lowerCamelCase__						       =      model(SCREAMING_SNAKE_CASE__		)

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





      def        _lowerCamelCase	(	self		) ->       List[str]:
         lowerCamelCase__						       =      self.prepare_config_and_inputs()
         lowerCamelCase__       ,							lowerCamelCase__       ,							lowerCamelCase__						       =      config_and_inputs
         lowerCamelCase__						       =      {"pixel_values": pixel_values}
         return config, inputs_dict






@require_torch
class 		_A							(      __a					,							__a					,							unittest.TestCase       ):
      __a             =						(SwinaSRModel, SwinaSRForImageSuperResolution) if is_torch_available() else ()
      __a             =						{'feature-extraction': SwinaSRModel} if is_torch_available() else {}

      __a             =						False
      __a             =						False
      __a             =						False
      __a             =						False
      __a             =						False





      def        _lowerCamelCase	(	self		) ->       Dict:
         lowerCamelCase__						       =      SwinaSRModelTester(self		)
         lowerCamelCase__						       =      ConfigTester(self     ,    config_class=SCREAMING_SNAKE_CASE__     ,    embed_dim=37		)





      def        _lowerCamelCase	(	self		) ->       str:
         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        _lowerCamelCase	(	self		) ->       Optional[Any]:
         lowerCamelCase__						       =      self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__		)





      def        _lowerCamelCase	(	self		) ->       Optional[int]:
         lowerCamelCase__						       =      self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_super_resolution(*SCREAMING_SNAKE_CASE__		)





      @unittest.skip(reason="Got `CUDA error: misaligned address` with PyTorch 2.0.0."		)
      def        _lowerCamelCase	(	self		) ->       Dict:
         pass





      @unittest.skip(reason="Swin2SR does not use inputs_embeds"		)
      def        _lowerCamelCase	(	self		) ->       Union[str, Any]:
         pass





      @unittest.skip(reason="Swin2SR does not support training yet"		)
      def        _lowerCamelCase	(	self		) ->       Union[str, Any]:
         pass





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





      def        _lowerCamelCase	(	self		) ->       Any:
         lowerCamelCase__       ,							lowerCamelCase__						       =      self.model_tester.prepare_config_and_inputs_for_common()

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





      def        _lowerCamelCase	(	self		) ->       List[Any]:
         lowerCamelCase__       ,							lowerCamelCase__						       =      self.model_tester.prepare_config_and_inputs_for_common()

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

            lowerCamelCase__						       =      ["pixel_values"]
            self.assertListEqual(arg_names[:1]     ,    SCREAMING_SNAKE_CASE__		)





      @slow
      def        _lowerCamelCase	(	self		) ->       List[Any]:
         for model_name in SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            lowerCamelCase__						       =      SwinaSRModel.from_pretrained(SCREAMING_SNAKE_CASE__		)
            self.assertIsNotNone(SCREAMING_SNAKE_CASE__		)





      def        _lowerCamelCase	(	self		) ->       Dict:
         lowerCamelCase__       ,							lowerCamelCase__						       =      self.model_tester.prepare_config_and_inputs_for_common()

         lowerCamelCase__						       =      _config_zero_init(SCREAMING_SNAKE_CASE__		)
         for model_class in self.all_model_classes:
            lowerCamelCase__						       =      model_class(config=SCREAMING_SNAKE_CASE__		)
            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        _lowerCamelCase	(	self		) ->       List[str]:
         lowerCamelCase__       ,							lowerCamelCase__						       =      self.model_tester.prepare_config_and_inputs_for_common()
         lowerCamelCase__						       =      True

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

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

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

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

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

            lowerCamelCase__						       =      outputs.attentions

            self.assertEqual(len(SCREAMING_SNAKE_CASE__		)     ,    SCREAMING_SNAKE_CASE__		)

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





      def        _lowerCamelCase	(	self		) ->       Dict:
         lowerCamelCase__						       =      SwinaSRImageProcessor()
         lowerCamelCase__						       =      SwinaSRForImageSuperResolution.from_pretrained("caidas/swin2SR-classical-sr-x2-64"		).to(SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						       =      Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"		)
         lowerCamelCase__						       =      processor(images=SCREAMING_SNAKE_CASE__     ,    return_tensors="pt"		).to(SCREAMING_SNAKE_CASE__		)

         # forward pass
         with torch.no_grad():
            lowerCamelCase__						       =      model(**SCREAMING_SNAKE_CASE__		)

         # verify the logits
         lowerCamelCase__						       =      torch.Size([1, 3, 976, 1296]		)
         self.assertEqual(outputs.reconstruction.shape     ,    SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						       =      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(SCREAMING_SNAKE_CASE__		)
         self.assertTrue(torch.allclose(outputs.reconstruction[0, 0, :3, :3]     ,    SCREAMING_SNAKE_CASE__     ,    atol=1e-4		)		)







"""simple docstring"""




SCREAMING_SNAKE_CASE_  :      Optional[int]							=      {0: [1, 2], 1: [0, 3], 2: [0], 3: [1], 4: [5, 6], 5: [4, 6], 6: [4, 5]}

SCREAMING_SNAKE_CASE_  :      str							=      {0: [1, 2, 3], 1: [0, 3], 2: [0], 3: [0, 1], 4: [], 5: []}



def 						UpperCAmelCase__ (					A__						,     A__						,     A__ )   ->   list:




   """simple docstring"""
   lowerCamelCase__						       =      True
   lowerCamelCase__						       =      []

   for neighbour in graph[vert]:
      if not visited[neighbour]:
         connected_verts += dfs(A__						,     A__						,     A__ )

   return [vert, *connected_verts]



def 						UpperCAmelCase__ (					A__ )   ->   list:




   """simple docstring"""
   lowerCamelCase__						       =      len(A__ )
   lowerCamelCase__						       =      graph_size * [False]
   lowerCamelCase__						       =      []

   for i in range(A__ ):
      if not visited[i]:
         lowerCamelCase__						       =      dfs(A__						,     A__						,     A__ )
         components_list.append(A__ )

   return components_list


if __name__ == "__main__":
     import doctest

     doctest.testmod()




