






import collections
import inspect
import unittest

from transformers import DonutSwinConfig
from transformers.testing_utils import require_torch, slow, torch_device
from transformers.utils import is_torch_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 DonutSwinModel
   from transformers.models.donut.modeling_donut_swin import DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST

class        snake_case_				:







   """simple docstring"""



   def __init__(     self:						str ,							snake_case__:						Dict ,							snake_case__:						List[str]=13 ,							snake_case__:						Any=32 ,							snake_case__:						List[Any]=2 ,							snake_case__:						Dict=3 ,							snake_case__:						Union[str, Any]=16 ,							snake_case__:						List[Any]=[1, 2, 1] ,							snake_case__:						Optional[int]=[2, 2, 4] ,							snake_case__:						Optional[int]=2 ,							snake_case__:						int=2.0 ,							snake_case__:						Optional[Any]=True ,							snake_case__:						Tuple=0.0 ,							snake_case__:						Dict=0.0 ,							snake_case__:						int=0.1 ,							snake_case__:						Union[str, Any]="gelu" ,							snake_case__:						Optional[Any]=False ,							snake_case__:						Tuple=True ,							snake_case__:						Optional[int]=0.02 ,							snake_case__:						int=1E-5 ,							snake_case__:						Optional[Any]=True ,							snake_case__:						int=None ,							snake_case__:						str=True ,							snake_case__:						List[str]=10 ,							snake_case__:						Dict=8 ,							)	->		int:


       """simple docstring"""



       _lowercase     			=						parent
       _lowercase     			=						batch_size
       _lowercase     			=						image_size
       _lowercase     			=						patch_size
       _lowercase     			=						num_channels
       _lowercase     			=						embed_dim
       _lowercase     			=						depths
       _lowercase     			=						num_heads
       _lowercase     			=						window_size
       _lowercase     			=						mlp_ratio
       _lowercase     			=						qkv_bias
       _lowercase     			=						hidden_dropout_prob
       _lowercase     			=						attention_probs_dropout_prob
       _lowercase     			=						drop_path_rate
       _lowercase     			=						hidden_act
       _lowercase     			=						use_absolute_embeddings
       _lowercase     			=						patch_norm
       _lowercase     			=						layer_norm_eps
       _lowercase     			=						initializer_range
       _lowercase     			=						is_training
       _lowercase     			=						scope
       _lowercase     			=						use_labels
       _lowercase     			=						type_sequence_label_size
       _lowercase     			=						encoder_stride

   def       SCREAMING_SNAKE_CASE__					(     self:						Tuple						)	->		Any:


       """simple docstring"""



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

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

       _lowercase     			=						self.get_config()

       return config, pixel_values, labels

   def       SCREAMING_SNAKE_CASE__					(     self:						Union[str, Any]						)	->		Optional[Any]:


       """simple docstring"""



       return DonutSwinConfig(
           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 ,							encoder_stride=self.encoder_stride ,							)

   def       SCREAMING_SNAKE_CASE__					(     self:						Dict ,							snake_case__:						Union[str, Any] ,							snake_case__:						str ,							snake_case__:						Optional[Any]						)	->		List[str]:


       """simple docstring"""



       _lowercase     			=						DonutSwinModel(config=snake_case__						)
       model.to(snake_case__						)
       model.eval()
       _lowercase     			=						model(snake_case__						)

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

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

   def       SCREAMING_SNAKE_CASE__					(     self:						Any						)	->		str:


       """simple docstring"""



       _lowercase     			=						self.prepare_config_and_inputs()
       (
           (
           _lowercase
       )			,     (
           _lowercase
       )			,     (
           _lowercase
       )			,     
       )     			=						config_and_inputs
       _lowercase     			=						{'pixel_values': pixel_values}
       return config, inputs_dict






@require_torch
class        snake_case_				(							lowercase_   ,      lowercase_   ,      unittest.TestCase   ):







   """simple docstring"""



   __lowerCAmelCase  =    (DonutSwinModel,) if is_torch_available() else ()
   __lowerCAmelCase  =    {"""feature-extraction""": DonutSwinModel} if is_torch_available() else {}
   __lowerCAmelCase  =    True

   __lowerCAmelCase  =    False
   __lowerCAmelCase  =    False
   __lowerCAmelCase  =    False

   def       SCREAMING_SNAKE_CASE__					(     self:						str						)	->		Optional[Any]:


       """simple docstring"""



       _lowercase     			=						DonutSwinModelTester(self						)
       _lowercase     			=						ConfigTester(self ,							config_class=snake_case__ ,							embed_dim=37						)

   def       SCREAMING_SNAKE_CASE__					(     self:						List[str]						)	->		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       SCREAMING_SNAKE_CASE__					(     self:						Dict						)	->		List[str]:


       """simple docstring"""



       return

   def       SCREAMING_SNAKE_CASE__					(     self:						List[str]						)	->		Union[str, Any]:


       """simple docstring"""



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

   def       SCREAMING_SNAKE_CASE__					(     self:						Union[str, Any]						)	->		Optional[int]:


       """simple docstring"""



       pass

   def       SCREAMING_SNAKE_CASE__					(     self:						List[str]						)	->		str:


       """simple docstring"""



       _lowercase			,     _lowercase     			=						self.model_tester.prepare_config_and_inputs_for_common()

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

   def       SCREAMING_SNAKE_CASE__					(     self:						Dict						)	->		Tuple:


       """simple docstring"""



       _lowercase			,     _lowercase     			=						self.model_tester.prepare_config_and_inputs_for_common()

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

           _lowercase     			=						['pixel_values']
           self.assertListEqual(arg_names[:1] ,							snake_case__						)

   def       SCREAMING_SNAKE_CASE__					(     self:						Any						)	->		Optional[int]:


       """simple docstring"""



       _lowercase			,     _lowercase     			=						self.model_tester.prepare_config_and_inputs_for_common()
       _lowercase     			=						True

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

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

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

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

           if hasattr(self.model_tester ,							'num_hidden_states_types'						):
               _lowercase     			=						self.model_tester.num_hidden_states_types
           else:
               # also another +1 for reshaped_hidden_states
               _lowercase     			=						2
           self.assertEqual(out_len + added_hidden_states ,							len(snake_case__						)						)

           _lowercase     			=						outputs.attentions

           self.assertEqual(len(snake_case__						) ,							snake_case__						)

           self.assertListEqual(
               list(self_attentions[0].shape[-3:]						) ,							[self.model_tester.num_heads[0], window_size_squared, window_size_squared] ,							)

   def       SCREAMING_SNAKE_CASE__					(     self:						List[str] ,							snake_case__:						Union[str, Any] ,							snake_case__:						Any ,							snake_case__:						Any ,							snake_case__:						Optional[Any]						)	->		List[Any]:


       """simple docstring"""



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

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

       _lowercase     			=						outputs.hidden_states

       _lowercase     			=						getattr(
           self.model_tester ,							'expected_num_hidden_layers' ,							len(self.model_tester.depths						) + 1						)
       self.assertEqual(len(snake_case__						) ,							snake_case__						)

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

       _lowercase     			=						(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

       self.assertListEqual(
           list(hidden_states[0].shape[-2:]						) ,							[num_patches, self.model_tester.embed_dim] ,							)

       _lowercase     			=						outputs.reshaped_hidden_states
       self.assertEqual(len(snake_case__						) ,							snake_case__						)

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

   def       SCREAMING_SNAKE_CASE__					(     self:						Optional[Any]						)	->		List[str]:


       """simple docstring"""



       _lowercase			,     _lowercase     			=						self.model_tester.prepare_config_and_inputs_for_common()

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

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

           self.check_hidden_states_output(snake_case__ ,							snake_case__ ,							snake_case__ ,							snake_case__						)

   def       SCREAMING_SNAKE_CASE__					(     self:						Optional[int]						)	->		List[Any]:


       """simple docstring"""



       _lowercase			,     _lowercase     			=						self.model_tester.prepare_config_and_inputs_for_common()
       _lowercase     			=						3

       _lowercase     			=						(
           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)
       )
       _lowercase     			=						(
           config.patch_size
           if isinstance(config.patch_size ,							collections.abc.Iterable						)
           else (config.patch_size, config.patch_size)
       )

       _lowercase     			=						image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
       _lowercase     			=						image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

       for model_class in self.all_model_classes:
           _lowercase     			=						True
           self.check_hidden_states_output(snake_case__ ,							snake_case__ ,							snake_case__ ,							(padded_height, padded_width)						)

           # check that output_hidden_states also work using config
           del inputs_dict["output_hidden_states"]
           _lowercase     			=						True
           self.check_hidden_states_output(snake_case__ ,							snake_case__ ,							snake_case__ ,							(padded_height, padded_width)						)

   @slow
   def       SCREAMING_SNAKE_CASE__					(     self:						Dict						)	->		str:


       """simple docstring"""



       for model_name in DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           _lowercase     			=						DonutSwinModel.from_pretrained(snake_case__						)
           self.assertIsNotNone(snake_case__						)

   def       SCREAMING_SNAKE_CASE__					(     self:						Any						)	->		int:


       """simple docstring"""



       _lowercase			,     _lowercase     			=						self.model_tester.prepare_config_and_inputs_for_common()

       _lowercase     			=						_config_zero_init(snake_case__						)
       for model_class in self.all_model_classes:
           _lowercase     			=						model_class(config=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''' ,							)








from typing import Literal

lowerCamelCase					    =	'''ABCDEFGHIJKLMNOPQRSTUVWXYZ'''
def 							UpperCAmelCase   ( _lowercase,   _lowercase,   _lowercase   ):


    '''simple docstring'''



    _lowercase     			=						LETTERS if mode == 'decrypt' else key
    _lowercase     			=						key if mode == 'decrypt' else LETTERS
    _lowercase     			=						''
    # loop through each symbol in the message
    for symbol in message:
        if symbol.upper() in chars_a:
            # encrypt/decrypt the symbol
            _lowercase     			=						chars_a.find(symbol.upper()   )
            if symbol.isupper():
                translated += chars_b[sym_index].upper()
            else:
                translated += chars_b[sym_index].lower()
        else:
            # symbol is not in LETTERS, just add it
            translated += symbol
    return translated
def 							UpperCAmelCase   ( _lowercase,   _lowercase   ):


    '''simple docstring'''



    return translate_message(_lowercase,   _lowercase,   'encrypt'   )
def 							UpperCAmelCase   ( _lowercase,   _lowercase   ):


    '''simple docstring'''



    return translate_message(_lowercase,   _lowercase,   'decrypt'   )
def 							UpperCAmelCase   ( ):


    '''simple docstring'''



    _lowercase     			=						'Hello World'
    _lowercase     			=						'QWERTYUIOPASDFGHJKLZXCVBNM'
    _lowercase     			=						'decrypt'  # set to 'encrypt' or 'decrypt'

    if mode == "encrypt":
        _lowercase     			=						encrypt_message(_lowercase,   _lowercase   )
    elif mode == "decrypt":
        _lowercase     			=						decrypt_message(_lowercase,   _lowercase   )
    print(f'''Using the key {key}, the {mode}ed message is: {translated}'''   )


if __name__ == "__main__":
   import doctest

   doctest.testmod()
   main()
