





"""simple docstring"""


import collections
import inspect
import unittest

from transformers import DinatConfig
from transformers.testing_utils import require_natten, require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
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 DinatBackbone, DinatForImageClassification, DinatModel
   from transformers.models.dinat.modeling_dinat import DINAT_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
   from PIL import Image

   from transformers import AutoImageProcessor



class   lowercase_					:

       def __init__(      self ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE=13 ,       __SCREAMING_SNAKE_CASE=64 ,       __SCREAMING_SNAKE_CASE=4 ,       __SCREAMING_SNAKE_CASE=3 ,       __SCREAMING_SNAKE_CASE=16 ,       __SCREAMING_SNAKE_CASE=[1, 2, 1] ,       __SCREAMING_SNAKE_CASE=[2, 4, 8] ,       __SCREAMING_SNAKE_CASE=3 ,       __SCREAMING_SNAKE_CASE=[[3], [1, 2], [1]] ,       __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=True ,       __SCREAMING_SNAKE_CASE=0.02 ,       __SCREAMING_SNAKE_CASE=1e-5 ,       __SCREAMING_SNAKE_CASE=True ,       __SCREAMING_SNAKE_CASE=None ,       __SCREAMING_SNAKE_CASE=True ,       __SCREAMING_SNAKE_CASE=10 ,       __SCREAMING_SNAKE_CASE=["stage1", "stage2"] ,       __SCREAMING_SNAKE_CASE=[1, 2] ,       ):






        '''simple docstring'''

        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__     				=					kernel_size
        snake_case__     				=					dilations
        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__     				=					patch_norm
        snake_case__     				=					layer_norm_eps
        snake_case__     				=					initializer_range
        snake_case__     				=					is_training
        snake_case__     				=					scope
        snake_case__     				=					use_labels
        snake_case__     				=					num_labels
        snake_case__     				=					out_features
        snake_case__     				=					out_indices

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        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.num_labels  )

        snake_case__     				=					self.get_config()

        return config, pixel_values, labels

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        return DinatConfig(
            num_labels=self.num_labels ,       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 ,       kernel_size=self.kernel_size ,       dilations=self.dilations ,       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 ,       patch_norm=self.patch_norm ,       layer_norm_eps=self.layer_norm_eps ,       initializer_range=self.initializer_range ,       out_features=self.out_features ,       out_indices=self.out_indices ,       )

       def 		_SCREAMING_SNAKE_CASE(      self ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE  ):






        '''simple docstring'''

        snake_case__     				=					DinatModel(config=__SCREAMING_SNAKE_CASE  )
        model.to(__SCREAMING_SNAKE_CASE  )
        model.eval()
        snake_case__     				=					model(__SCREAMING_SNAKE_CASE  )

        snake_case__     				=					snake_case__     				=					(config.image_size // config.patch_size) // (2 ** (len(config.depths  ) - 1))
        snake_case__     				=					int(config.embed_dim * 2 ** (len(config.depths  ) - 1)  )

        self.parent.assertEqual(
            result.last_hidden_state.shape ,       (self.batch_size, expected_height, expected_width, expected_dim)  )

       def 		_SCREAMING_SNAKE_CASE(      self ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE  ):






        '''simple docstring'''

        snake_case__     				=					DinatForImageClassification(__SCREAMING_SNAKE_CASE  )
        model.to(__SCREAMING_SNAKE_CASE  )
        model.eval()
        snake_case__     				=					model(__SCREAMING_SNAKE_CASE ,       labels=__SCREAMING_SNAKE_CASE  )
        self.parent.assertEqual(result.logits.shape ,       (self.batch_size, self.num_labels)  )

        # test greyscale images
        snake_case__     				=					1
        snake_case__     				=					DinatForImageClassification(__SCREAMING_SNAKE_CASE  )
        model.to(__SCREAMING_SNAKE_CASE  )
        model.eval()

        snake_case__     				=					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]  )
        snake_case__     				=					model(__SCREAMING_SNAKE_CASE  )
        self.parent.assertEqual(result.logits.shape ,       (self.batch_size, self.num_labels)  )

       def 		_SCREAMING_SNAKE_CASE(      self ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE  ):






        '''simple docstring'''

        snake_case__     				=					DinatBackbone(config=__SCREAMING_SNAKE_CASE  )
        model.to(__SCREAMING_SNAKE_CASE  )
        model.eval()
        snake_case__     				=					model(__SCREAMING_SNAKE_CASE  )

        # verify hidden states
        self.parent.assertEqual(len(result.feature_maps  ) ,       len(config.out_features  )  )
        self.parent.assertListEqual(list(result.feature_maps[0].shape  ) ,       [self.batch_size, model.channels[0], 16, 16]  )

        # verify channels
        self.parent.assertEqual(len(model.channels  ) ,       len(config.out_features  )  )

        # verify backbone works with out_features=None
        snake_case__     				=					None
        snake_case__     				=					DinatBackbone(config=__SCREAMING_SNAKE_CASE  )
        model.to(__SCREAMING_SNAKE_CASE  )
        model.eval()
        snake_case__     				=					model(__SCREAMING_SNAKE_CASE  )

        # verify feature maps
        self.parent.assertEqual(len(result.feature_maps  ) ,       1  )
        self.parent.assertListEqual(list(result.feature_maps[0].shape  ) ,       [self.batch_size, model.channels[-1], 4, 4]  )

        # verify channels
        self.parent.assertEqual(len(model.channels  ) ,       1  )

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        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_natten
@require_torch
class   lowercase_					(  __lowerCAmelCase					,__lowerCAmelCase					,unittest.TestCase				):
       snake_case__					:				List[Any]									=  (
           (
               DinatModel,
               DinatForImageClassification,
               DinatBackbone,
           )
           if is_torch_available()
           else ()
       )
       snake_case__					:				int									=  (
           {"""feature-extraction""": DinatModel, """image-classification""": DinatForImageClassification}
           if is_torch_available()
           else {}
       )
       snake_case__					:				Optional[int]									=  False

       snake_case__					:				Dict									=  False
       snake_case__					:				Dict									=  False
       snake_case__					:				Union[str, Any]									=  False
       snake_case__					:				int									=  False

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        snake_case__     				=					DinatModelTester(self  )
        snake_case__     				=					ConfigTester(self ,       config_class=__SCREAMING_SNAKE_CASE ,       embed_dim=37  )

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        self.create_and_test_config_common_properties()
        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  ):






        '''simple docstring'''

        return

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        snake_case__     				=					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE  )

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        snake_case__     				=					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*__SCREAMING_SNAKE_CASE  )

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        snake_case__     				=					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_backbone(*__SCREAMING_SNAKE_CASE  )

       @unittest.skip(reason="Dinat does not use inputs_embeds"  )
       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        pass

       @unittest.skip(reason="Dinat does not use feedforward chunking"  )
       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        pass

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        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(__SCREAMING_SNAKE_CASE  )
         self.assertIsInstance(model.get_input_embeddings() ,       (nn.Module)  )
         snake_case__     				=					model.get_output_embeddings()
         self.assertTrue(x is None or isinstance(__SCREAMING_SNAKE_CASE ,       nn.Linear  )  )

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        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(__SCREAMING_SNAKE_CASE  )
         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] ,       __SCREAMING_SNAKE_CASE  )

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        self.skipTest("Dinat's attention operation is handled entirely by NATTEN."  )

       def 		_SCREAMING_SNAKE_CASE(      self ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE  ):






        '''simple docstring'''

        snake_case__     				=					model_class(__SCREAMING_SNAKE_CASE  )
        model.to(__SCREAMING_SNAKE_CASE  )
        model.eval()

        with torch.no_grad():
         snake_case__     				=					model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE  )  )

        snake_case__     				=					outputs.hidden_states

        snake_case__     				=					getattr(
            self.model_tester ,       "expected_num_hidden_layers" ,       len(self.model_tester.depths  ) + 1  )
        self.assertEqual(len(__SCREAMING_SNAKE_CASE  ) ,       __SCREAMING_SNAKE_CASE  )

        # Dinat has a different seq_length
        snake_case__     				=					(
            config.patch_size
            if isinstance(config.patch_size ,       collections.abc.Iterable  )
            else (config.patch_size, config.patch_size)
        )

        snake_case__     				=					image_size[0] // patch_size[0]
        snake_case__     				=					image_size[1] // patch_size[1]

        self.assertListEqual(
            list(hidden_states[0].shape[-3:]  ) ,       [height, width, self.model_tester.embed_dim] ,       )

        if model_class.__name__ != "DinatBackbone":
         snake_case__     				=					outputs.reshaped_hidden_states
         self.assertEqual(len(__SCREAMING_SNAKE_CASE  ) ,       __SCREAMING_SNAKE_CASE  )

         snake_case__				, snake_case__				, snake_case__				, snake_case__     				=					reshaped_hidden_states[0].shape
         snake_case__     				=					(
             reshaped_hidden_states[0].view(__SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE  ).permute(0 ,       2 ,       3 ,       1  )
         )
         self.assertListEqual(
             list(reshaped_hidden_states.shape[-3:]  ) ,       [height, width, self.model_tester.embed_dim] ,       )

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        snake_case__				, snake_case__     				=					self.model_tester.prepare_config_and_inputs_for_common()

        snake_case__     				=					(
            self.model_tester.image_size
            if isinstance(self.model_tester.image_size ,       collections.abc.Iterable  )
            else (self.model_tester.image_size, self.model_tester.image_size)
        )

        for model_class in self.all_model_classes:
         snake_case__     				=					True
         self.check_hidden_states_output(__SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE  )

         # check that output_hidden_states also work using config
         del inputs_dict["output_hidden_states"]
         snake_case__     				=					True

         self.check_hidden_states_output(__SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE  )

       @slow
       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        for model_name in DINAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         snake_case__     				=					DinatModel.from_pretrained(__SCREAMING_SNAKE_CASE  )
         self.assertIsNotNone(__SCREAMING_SNAKE_CASE  )

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        snake_case__				, snake_case__     				=					self.model_tester.prepare_config_and_inputs_for_common()

        snake_case__     				=					_config_zero_init(__SCREAMING_SNAKE_CASE  )
        for model_class in self.all_model_classes:
         snake_case__     				=					model_class(config=__SCREAMING_SNAKE_CASE  )
         for name, param in model.named_parameters():
          if "embeddings" not in name and 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" ,       )



@require_natten
@require_vision
@require_torch
class   lowercase_					(  unittest.TestCase				):

       @cached_property
       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        return AutoImageProcessor.from_pretrained("shi-labs/dinat-mini-in1k-224"  ) if is_vision_available() else None

       @slow
       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        snake_case__     				=					DinatForImageClassification.from_pretrained("shi-labs/dinat-mini-in1k-224"  ).to(__SCREAMING_SNAKE_CASE  )
        snake_case__     				=					self.default_image_processor

        snake_case__     				=					Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"  )
        snake_case__     				=					image_processor(images=__SCREAMING_SNAKE_CASE ,       return_tensors="pt"  ).to(__SCREAMING_SNAKE_CASE  )

        # forward pass
        with torch.no_grad():
         snake_case__     				=					model(**__SCREAMING_SNAKE_CASE  )

        # verify the logits
        snake_case__     				=					torch.Size((1, 1000)  )
        self.assertEqual(outputs.logits.shape ,       __SCREAMING_SNAKE_CASE  )
        snake_case__     				=					torch.tensor([-0.1545, -0.7667, 0.4642]  ).to(__SCREAMING_SNAKE_CASE  )
        self.assertTrue(torch.allclose(outputs.logits[0, :3] ,       __SCREAMING_SNAKE_CASE ,       atol=1e-4  )  )



@require_torch
@require_natten
class   lowercase_					(  unittest.TestCase					,__lowerCAmelCase				):
       snake_case__					:				Optional[int]									=  (DinatBackbone,) if is_torch_available() else ()
       snake_case__					:				Dict									=  DinatConfig

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        snake_case__     				=					DinatModelTester(self  )








"""simple docstring"""


a__       :  Optional[Any]       		=					{
    """A""": ("""ABCDEFGHIJKLM""", """NOPQRSTUVWXYZ"""),
    """B""": ("""ABCDEFGHIJKLM""", """NOPQRSTUVWXYZ"""),
    """C""": ("""ABCDEFGHIJKLM""", """ZNOPQRSTUVWXY"""),
    """D""": ("""ABCDEFGHIJKLM""", """ZNOPQRSTUVWXY"""),
    """E""": ("""ABCDEFGHIJKLM""", """YZNOPQRSTUVWX"""),
    """F""": ("""ABCDEFGHIJKLM""", """YZNOPQRSTUVWX"""),
    """G""": ("""ABCDEFGHIJKLM""", """XYZNOPQRSTUVW"""),
    """H""": ("""ABCDEFGHIJKLM""", """XYZNOPQRSTUVW"""),
    """I""": ("""ABCDEFGHIJKLM""", """WXYZNOPQRSTUV"""),
    """J""": ("""ABCDEFGHIJKLM""", """WXYZNOPQRSTUV"""),
    """K""": ("""ABCDEFGHIJKLM""", """VWXYZNOPQRSTU"""),
    """L""": ("""ABCDEFGHIJKLM""", """VWXYZNOPQRSTU"""),
    """M""": ("""ABCDEFGHIJKLM""", """UVWXYZNOPQRST"""),
    """N""": ("""ABCDEFGHIJKLM""", """UVWXYZNOPQRST"""),
    """O""": ("""ABCDEFGHIJKLM""", """TUVWXYZNOPQRS"""),
    """P""": ("""ABCDEFGHIJKLM""", """TUVWXYZNOPQRS"""),
    """Q""": ("""ABCDEFGHIJKLM""", """STUVWXYZNOPQR"""),
    """R""": ("""ABCDEFGHIJKLM""", """STUVWXYZNOPQR"""),
    """S""": ("""ABCDEFGHIJKLM""", """RSTUVWXYZNOPQ"""),
    """T""": ("""ABCDEFGHIJKLM""", """RSTUVWXYZNOPQ"""),
    """U""": ("""ABCDEFGHIJKLM""", """QRSTUVWXYZNOP"""),
    """V""": ("""ABCDEFGHIJKLM""", """QRSTUVWXYZNOP"""),
    """W""": ("""ABCDEFGHIJKLM""", """PQRSTUVWXYZNO"""),
    """X""": ("""ABCDEFGHIJKLM""", """PQRSTUVWXYZNO"""),
    """Y""": ("""ABCDEFGHIJKLM""", """OPQRSTUVWXYZN"""),
    """Z""": ("""ABCDEFGHIJKLM""", """OPQRSTUVWXYZN"""),
}





def 				a__      (	_UpperCAmelCase						)     ->	list[tuple[str, str]]:

 '''simple docstring'''






 return [alphabet[char] for char in key.upper()]





def 				a__      (	_UpperCAmelCase						,  _UpperCAmelCase						)     ->	str:

 '''simple docstring'''






 snake_case__     				=					""
 snake_case__     				=					0
 snake_case__     				=					generate_table(_UpperCAmelCase						)
 for char in words.upper():
  cipher += get_opponent(table[count]						,  _UpperCAmelCase						)
  snake_case__     				=					(count + 1) % len(_UpperCAmelCase						)
 return cipher





def 				a__      (	_UpperCAmelCase						,  _UpperCAmelCase						)     ->	str:

 '''simple docstring'''






 return encrypt(_UpperCAmelCase						,  _UpperCAmelCase						)





def 				a__      (	_UpperCAmelCase						,  _UpperCAmelCase						)     ->	tuple[int, int]:

 '''simple docstring'''






 snake_case__     				=					0 if char in table[0] else 1
 snake_case__     				=					table[row].index(_UpperCAmelCase						)
 return row, col





def 				a__      (	_UpperCAmelCase						,  _UpperCAmelCase						)     ->	str:

 '''simple docstring'''






 snake_case__				, snake_case__     				=					get_position(_UpperCAmelCase						,  char.upper()						)
 if row == 1:
  return table[0][col]
 else:
  return table[1][col] if row == 0 else char


if __name__ == "__main__":
   import doctest

   doctest.testmod()  # Fist ensure that all our tests are passing...
   a__       :  int       		=					input("""Enter key: """).strip()
   a__       :  Optional[int]       		=					input("""Enter text to encrypt: """).strip()
   a__       :  Dict       		=					encrypt(key, text)

   print(f'''Encrypted: {cipher_text}''')
   print(f'''Decrypted with key: {decrypt(key, cipher_text)}''')

