




import collections
import inspect
import unittest

from transformers import NatConfig
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 NatBackbone, NatForImageClassification, NatModel
  from transformers.models.nat.modeling_nat import NAT_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
  from PIL import Image

  from transformers import AutoImageProcessor

class 	__lowerCAmelCase			:
       def __init__(		self		:Any	,   __magic_name__		:Optional[int]	,   __magic_name__		:int=13	,   __magic_name__		:Tuple=64	,   __magic_name__		:str=4	,   __magic_name__		:List[str]=3	,   __magic_name__		:Optional[int]=16	,   __magic_name__		:Union[str, Any]=[1, 2, 1]	,   __magic_name__		:Dict=[2, 4, 8]	,   __magic_name__		:Dict=3	,   __magic_name__		:List[Any]=2.0	,   __magic_name__		:Optional[int]=True	,   __magic_name__		:Optional[int]=0.0	,   __magic_name__		:List[Any]=0.0	,   __magic_name__		:Dict=0.1	,   __magic_name__		:Tuple="gelu"	,   __magic_name__		:List[Any]=True	,   __magic_name__		:Dict=0.02	,   __magic_name__		:Optional[Any]=1E-5	,   __magic_name__		:Tuple=True	,   __magic_name__		:Union[str, Any]=None	,   __magic_name__		:List[Any]=True	,   __magic_name__		:Any=10	,   __magic_name__		:Union[str, Any]=["stage1", "stage2"]	,   __magic_name__		:int=[1, 2]	,   ):







        '''simple docstring'''







        a		       =							parent
        a		       =							batch_size
        a		       =							image_size
        a		       =							patch_size
        a		       =							num_channels
        a		       =							embed_dim
        a		       =							depths
        a		       =							num_heads
        a		       =							kernel_size
        a		       =							mlp_ratio
        a		       =							qkv_bias
        a		       =							hidden_dropout_prob
        a		       =							attention_probs_dropout_prob
        a		       =							drop_path_rate
        a		       =							hidden_act
        a		       =							patch_norm
        a		       =							layer_norm_eps
        a		       =							initializer_range
        a		       =							is_training
        a		       =							scope
        a		       =							use_labels
        a		       =							num_labels
        a		       =							out_features
        a		       =							out_indices
       def    lowerCamelCase__							(		self		:int       ):







        '''simple docstring'''







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

        a		       =							None
        if self.use_labels:
         a		       =							ids_tensor([self.batch_size]	,   self.num_labels       )

        a		       =							self.get_config()

        return config, pixel_values, labels
       def    lowerCamelCase__							(		self		:Union[str, Any]       ):







        '''simple docstring'''







        return NatConfig(
            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	,   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    lowerCamelCase__							(		self		:Optional[Any]	,   __magic_name__		:List[str]	,   __magic_name__		:int	,   __magic_name__		:List[Any]       ):







        '''simple docstring'''







        a		       =							NatModel(config=__magic_name__       )
        model.to(__magic_name__       )
        model.eval()
        a		       =							model(__magic_name__       )

        a		       =							a		       =							(config.image_size // config.patch_size) // (2 ** (len(config.depths       ) - 1))
        a		       =							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    lowerCamelCase__							(		self		:Union[str, Any]	,   __magic_name__		:List[str]	,   __magic_name__		:Union[str, Any]	,   __magic_name__		:Any       ):







        '''simple docstring'''







        a		       =							NatForImageClassification(__magic_name__       )
        model.to(__magic_name__       )
        model.eval()
        a		       =							model(__magic_name__	,   labels=__magic_name__       )
        self.parent.assertEqual(result.logits.shape	,   (self.batch_size, self.num_labels)       )

        # test greyscale images
        a		       =							1
        a		       =							NatForImageClassification(__magic_name__       )
        model.to(__magic_name__       )
        model.eval()

        a		       =							floats_tensor([self.batch_size, 1, self.image_size, self.image_size]       )
        a		       =							model(__magic_name__       )
        self.parent.assertEqual(result.logits.shape	,   (self.batch_size, self.num_labels)       )
       def    lowerCamelCase__							(		self		:Optional[int]	,   __magic_name__		:Optional[Any]	,   __magic_name__		:int	,   __magic_name__		:Any       ):







        '''simple docstring'''







        a		       =							NatBackbone(config=__magic_name__       )
        model.to(__magic_name__       )
        model.eval()
        a		       =							model(__magic_name__       )

        # 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
        a		       =							None
        a		       =							NatBackbone(config=__magic_name__       )
        model.to(__magic_name__       )
        model.eval()
        a		       =							model(__magic_name__       )

        # 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    lowerCamelCase__							(		self		:Dict       ):







        '''simple docstring'''







        a		       =							self.prepare_config_and_inputs()
        a       ,				a       ,				a		       =							config_and_inputs
        a		       =							{"""pixel_values""": pixel_values}
        return config, inputs_dict







@require_natten
@require_torch
class 	__lowerCAmelCase			(			__magic_name__   , __magic_name__   , unittest.TestCase				):
       UpperCamelCase__        =						(
           (
               NatModel,
               NatForImageClassification,
               NatBackbone,
           )
           if is_torch_available()
           else ()
       )
       UpperCamelCase__        =						(
           {'''feature-extraction''': NatModel, '''image-classification''': NatForImageClassification}
           if is_torch_available()
           else {}
       )
       UpperCamelCase__        =						False

       UpperCamelCase__        =						False
       UpperCamelCase__        =						False
       UpperCamelCase__        =						False
       UpperCamelCase__        =						False
       def    lowerCamelCase__							(		self		:str       ):







        '''simple docstring'''







        a		       =							NatModelTester(self       )
        a		       =							ConfigTester(self	,   config_class=__magic_name__	,   embed_dim=37       )
       def    lowerCamelCase__							(		self		:Dict       ):







        '''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    lowerCamelCase__							(		self		:Any       ):







        '''simple docstring'''







        return
       def    lowerCamelCase__							(		self		:Any       ):







        '''simple docstring'''







        a		       =							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*__magic_name__       )
       def    lowerCamelCase__							(		self		:List[str]       ):







        '''simple docstring'''







        a		       =							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*__magic_name__       )
       def    lowerCamelCase__							(		self		:List[Any]       ):







        '''simple docstring'''







        a		       =							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_backbone(*__magic_name__       )
       @unittest.skip(reason="""Nat does not use inputs_embeds"""       )
       def    lowerCamelCase__							(		self		:int       ):







        '''simple docstring'''







        pass
       @unittest.skip(reason="""Nat does not use feedforward chunking"""       )
       def    lowerCamelCase__							(		self		:Union[str, Any]       ):







        '''simple docstring'''







        pass
       def    lowerCamelCase__							(		self		:Optional[Any]       ):







        '''simple docstring'''







        a       ,				a		       =							self.model_tester.prepare_config_and_inputs_for_common()

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







        '''simple docstring'''







        a       ,				a		       =							self.model_tester.prepare_config_and_inputs_for_common()

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

         a		       =							["""pixel_values"""]
         self.assertListEqual(arg_names[:1]	,   __magic_name__       )
       def    lowerCamelCase__							(		self		:Dict       ):







        '''simple docstring'''







        self.skipTest("""Nat's attention operation is handled entirely by NATTEN."""       )
       def    lowerCamelCase__							(		self		:int	,   __magic_name__		:int	,   __magic_name__		:Optional[Any]	,   __magic_name__		:Optional[Any]	,   __magic_name__		:Optional[Any]       ):







        '''simple docstring'''







        a		       =							model_class(__magic_name__       )
        model.to(__magic_name__       )
        model.eval()

        with torch.no_grad():
         a		       =							model(**self._prepare_for_class(__magic_name__	,   __magic_name__       )       )

        a		       =							outputs.hidden_states

        a		       =							getattr(
            self.model_tester	,   """expected_num_hidden_layers"""	,   len(self.model_tester.depths       ) + 1       )
        self.assertEqual(len(__magic_name__       )	,   __magic_name__       )

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

        a		       =							image_size[0] // patch_size[0]
        a		       =							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__ != "NatBackbone":
         a		       =							outputs.reshaped_hidden_states
         self.assertEqual(len(__magic_name__       )	,   __magic_name__       )

         a       ,				a       ,				a       ,				a		       =							reshaped_hidden_states[0].shape
         a		       =							(
             reshaped_hidden_states[0].view(__magic_name__	,   __magic_name__	,   __magic_name__	,   __magic_name__       ).permute(0	,   2	,   3	,   1       )
         )
         self.assertListEqual(
             list(reshaped_hidden_states.shape[-3:]       )	,   [height, width, self.model_tester.embed_dim]	,   )
       def    lowerCamelCase__							(		self		:Tuple       ):







        '''simple docstring'''







        a       ,				a		       =							self.model_tester.prepare_config_and_inputs_for_common()

        a		       =							(
            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:
         a		       =							True
         self.check_hidden_states_output(__magic_name__	,   __magic_name__	,   __magic_name__	,   __magic_name__       )

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

         self.check_hidden_states_output(__magic_name__	,   __magic_name__	,   __magic_name__	,   __magic_name__       )
       @slow
       def    lowerCamelCase__							(		self		:Optional[int]       ):







        '''simple docstring'''







        for model_name in NAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         a		       =							NatModel.from_pretrained(__magic_name__       )
         self.assertIsNotNone(__magic_name__       )





       def    lowerCamelCase__							(		self		:Any       ):







        '''simple docstring'''







        a       ,				a		       =							self.model_tester.prepare_config_and_inputs_for_common()

        a		       =							_config_zero_init(__magic_name__       )
        for model_class in self.all_model_classes:
         a		       =							model_class(config=__magic_name__       )
         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 	__lowerCAmelCase			(			unittest.TestCase				):
       @cached_property
       def    lowerCamelCase__							(		self		:Optional[Any]       ):







        '''simple docstring'''







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





       @slow
       def    lowerCamelCase__							(		self		:Optional[int]       ):







        '''simple docstring'''







        a		       =							NatForImageClassification.from_pretrained("""shi-labs/nat-mini-in1k-224"""       ).to(__magic_name__       )
        a		       =							self.default_image_processor

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

        # forward pass
        with torch.no_grad():
         a		       =							model(**__magic_name__       )

        # verify the logits
        a		       =							torch.Size((1, 1000)       )
        self.assertEqual(outputs.logits.shape	,   __magic_name__       )
        a		       =							torch.tensor([0.3805, -0.8676, -0.3912]       ).to(__magic_name__       )
        self.assertTrue(torch.allclose(outputs.logits[0, :3]	,   __magic_name__	,   atol=1E-4       )       )







@require_torch
@require_natten
class 	__lowerCAmelCase			(			unittest.TestCase   , __magic_name__				):
       UpperCamelCase__        =						(NatBackbone,) if is_torch_available() else ()
       UpperCamelCase__        =						NatConfig
       def    lowerCamelCase__							(		self		:List[str]       ):







        '''simple docstring'''







        a		       =							NatModelTester(self       )







__UpperCamelCase      : Union[str, 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	(			__lowerCamelCase					)   -> list[tuple[str, str]]:
	return [alphabet[char] for char in key.upper()]





def 	__A	(			__lowerCamelCase							,    __lowerCamelCase					)   -> str:
	a		       =							""""""
	a		       =							0
	a		       =							generate_table(__lowerCamelCase					)
	for char in words.upper():
		cipher += get_opponent(table[count]							,    __lowerCamelCase					)
		a		       =							(count + 1) % len(__lowerCamelCase					)
	return cipher





def 	__A	(			__lowerCamelCase							,    __lowerCamelCase					)   -> str:
	return encrypt(__lowerCamelCase							,    __lowerCamelCase					)





def 	__A	(			__lowerCamelCase							,    __lowerCamelCase					)   -> tuple[int, int]:
	a		       =							0 if char in table[0] else 1
	a		       =							table[row].index(__lowerCamelCase					)
	return row, col





def 	__A	(			__lowerCamelCase							,    __lowerCamelCase					)   -> str:
	a       ,				a		       =							get_position(__lowerCamelCase							,    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...
		__UpperCamelCase      : int					      =   input("Enter key: ").strip()
		__UpperCamelCase      : int					      =   input("Enter text to encrypt: ").strip()
		__UpperCamelCase      : Optional[Any]					      =   encrypt(key, text)

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

