






"""simple docstring"""



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



    '''simple docstring'''


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


    def 		A__      (      self			):
     UpperCAmelCase__ 						=				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

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

     UpperCAmelCase__ 						=				self.get_config()

     return config, pixel_values, labels


    def 		A__      (      self			):
     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 		A__      (      self   ,			__lowercase   ,			__lowercase   ,			__lowercase			):
     UpperCAmelCase__ 						=				DonutSwinModel(config=__lowercase			)
     model.to(__lowercase			)
     model.eval()
     UpperCAmelCase__ 						=				model(__lowercase			)

     UpperCAmelCase__ 						=				((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths			) - 1))
     UpperCAmelCase__ 						=				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 		A__      (      self			):
     UpperCAmelCase__ 						=				self.prepare_config_and_inputs()
     (
         (
         UpperCAmelCase__
     )						,	(
         UpperCAmelCase__
     )						,	(
         UpperCAmelCase__
     )						,	
     ) 						=				config_and_inputs
     UpperCAmelCase__ 						=				{"""pixel_values""": pixel_values}
     return config, inputs_dict



@require_torch
class 	_UpperCamelCase ( __UpperCamelCase		,     __UpperCamelCase		,     unittest.TestCase							):



    '''simple docstring'''


    __lowercase    :   int											=						(DonutSwinModel,) if is_torch_available() else ()
    __lowercase    :   str											=						{'feature-extraction': DonutSwinModel} if is_torch_available() else {}
    __lowercase    :   List[str]											=						True

    __lowercase    :   Union[str, Any]											=						False
    __lowercase    :   List[str]											=						False
    __lowercase    :   Optional[int]											=						False


    def 		A__      (      self			):
     UpperCAmelCase__ 						=				DonutSwinModelTester(self			)
     UpperCAmelCase__ 						=				ConfigTester(self   ,			config_class=__lowercase   ,			embed_dim=37			)


    def 		A__      (      self			):
     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 		A__      (      self			):
     return


    def 		A__      (      self			):
     UpperCAmelCase__ 						=				self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*__lowercase			)


    def 		A__      (      self			):
     # DonutSwin does not use inputs_embeds
     pass


    def 		A__      (      self			):
     UpperCAmelCase__						,	UpperCAmelCase__ 						=				self.model_tester.prepare_config_and_inputs_for_common()

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


    def 		A__      (      self			):
     UpperCAmelCase__						,	UpperCAmelCase__ 						=				self.model_tester.prepare_config_and_inputs_for_common()

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

      UpperCAmelCase__ 						=				["""pixel_values"""]
      self.assertListEqual(arg_names[:1]   ,			__lowercase			)


    def 		A__      (      self			):
     UpperCAmelCase__						,	UpperCAmelCase__ 						=				self.model_tester.prepare_config_and_inputs_for_common()
     UpperCAmelCase__ 						=				True

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

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

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

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

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

      UpperCAmelCase__ 						=				outputs.attentions

      self.assertEqual(len(__lowercase			)   ,			__lowercase			)

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


    def 		A__      (      self   ,			__lowercase   ,			__lowercase   ,			__lowercase   ,			__lowercase			):
     UpperCAmelCase__ 						=				model_class(__lowercase			)
     model.to(__lowercase			)
     model.eval()

     with torch.no_grad():
      UpperCAmelCase__ 						=				model(**self._prepare_for_class(__lowercase   ,			__lowercase			)			)

     UpperCAmelCase__ 						=				outputs.hidden_states

     UpperCAmelCase__ 						=				getattr(
         self.model_tester   ,			"""expected_num_hidden_layers"""   ,			len(self.model_tester.depths			) + 1			)
     self.assertEqual(len(__lowercase			)   ,			__lowercase			)

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

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

     UpperCAmelCase__ 						=				outputs.reshaped_hidden_states
     self.assertEqual(len(__lowercase			)   ,			__lowercase			)

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


    def 		A__      (      self			):
     UpperCAmelCase__						,	UpperCAmelCase__ 						=				self.model_tester.prepare_config_and_inputs_for_common()

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

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

      self.check_hidden_states_output(__lowercase   ,			__lowercase   ,			__lowercase   ,			__lowercase			)


    def 		A__      (      self			):
     UpperCAmelCase__						,	UpperCAmelCase__ 						=				self.model_tester.prepare_config_and_inputs_for_common()
     UpperCAmelCase__ 						=				3

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

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

     for model_class in self.all_model_classes:
      UpperCAmelCase__ 						=				True
      self.check_hidden_states_output(__lowercase   ,			__lowercase   ,			__lowercase   ,			(padded_height, padded_width)			)

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


    @slow
    def 		A__      (      self			):
     for model_name in DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
      UpperCAmelCase__ 						=				DonutSwinModel.from_pretrained(__lowercase			)
      self.assertIsNotNone(__lowercase			)






    def 		A__      (      self			):
     UpperCAmelCase__						,	UpperCAmelCase__ 						=				self.model_tester.prepare_config_and_inputs_for_common()

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











"""simple docstring"""



import itertools
from pathlib import Path




def       snake_case__		(   _SCREAMING_SNAKE_CASE			)    ->int:
 UpperCAmelCase__ 						=				[tuple(_SCREAMING_SNAKE_CASE			) for login in logins]

 UpperCAmelCase__ 						=				{char for login in split_logins for char in login}

 for permutation in itertools.permutations(_SCREAMING_SNAKE_CASE			):
  UpperCAmelCase__ 						=				True
  for login in logins:
   if not (
       permutation.index(login[0]			)
       < permutation.index(login[1]			)
       < permutation.index(login[2]			)
   ):
    UpperCAmelCase__ 						=				False
    break

  if satisfied:
   return int("""""".join(_SCREAMING_SNAKE_CASE			)			)

 raise Exception("""Unable to find the secret passcode"""			)




def       snake_case__		(   _SCREAMING_SNAKE_CASE = "keylog.txt"			)    ->int:
 UpperCAmelCase__ 						=				Path(_SCREAMING_SNAKE_CASE			).parent.joinpath(_SCREAMING_SNAKE_CASE			).read_text().splitlines()

 return find_secret_passcode(_SCREAMING_SNAKE_CASE			)


if __name__ == "__main__":
 print(F'''{solution() = }''')



