

'''simple docstring'''

from __future__ import annotations

import unittest

from transformers import EsmConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
       import numpy
       import tensorflow as tf

       from transformers.models.esm.modeling_tf_esm import (
           TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST,
           TFEsmForMaskedLM,
           TFEsmForSequenceClassification,
           TFEsmForTokenClassification,
           TFEsmModel,
       )


class 	lowerCAmelCase  :







       def __init__(				self      :			List[Any]    ,   __lowercase      :			Tuple    ,   ):







            """simple docstring"""







            __lowercase      		=parent
            __lowercase      		=13
            __lowercase      		=7
            __lowercase      		=True
            __lowercase      		=True
            __lowercase      		=True
            __lowercase      		=99
            __lowercase      		=32
            __lowercase      		=2
            __lowercase      		=4
            __lowercase      		=37
            __lowercase      		='gelu'
            __lowercase      		=0.1
            __lowercase      		=0.1
            __lowercase      		=512
            __lowercase      		=16
            __lowercase      		=2
            __lowercase      		=0.0_2
            __lowercase      		=3
            __lowercase      		=4
            __lowercase      		=None







       def       snake_case (				self      :			List[Any]   ):







            """simple docstring"""







            __lowercase      		=ids_tensor([self.batch_size, self.seq_length]    ,   self.vocab_size   )

            __lowercase      		=None
            if self.use_input_mask:
                 __lowercase      		=random_attention_mask([self.batch_size, self.seq_length]   )

            __lowercase      		=None
            __lowercase      		=None
            __lowercase      		=None
            if self.use_labels:
                 __lowercase      		=ids_tensor([self.batch_size]    ,   self.type_sequence_label_size   )
                 __lowercase      		=ids_tensor([self.batch_size, self.seq_length]    ,   self.num_labels   )
                 __lowercase      		=ids_tensor([self.batch_size]    ,   self.num_choices   )

            __lowercase      		=EsmConfig(
                vocab_size=self.vocab_size    ,   hidden_size=self.hidden_size    ,   num_hidden_layers=self.num_hidden_layers    ,   pad_token_id=1    ,   num_attention_heads=self.num_attention_heads    ,   intermediate_size=self.intermediate_size    ,   hidden_act=self.hidden_act    ,   hidden_dropout_prob=self.hidden_dropout_prob    ,   attention_probs_dropout_prob=self.attention_probs_dropout_prob    ,   max_position_embeddings=self.max_position_embeddings    ,   type_vocab_size=self.type_vocab_size    ,   initializer_range=self.initializer_range    ,   )

            return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels







       def       snake_case (				self      :			Any   ):







            """simple docstring"""







            (
                (
                __lowercase
            )		,  (
                __lowercase
            )		,  (
                __lowercase
            )		,  (
                __lowercase
            )		,  (
                __lowercase
            )		,  (
                __lowercase
            )		,  
            )      		=self.prepare_config_and_inputs()

            __lowercase      		=True
            __lowercase      		=floats_tensor([self.batch_size, self.seq_length, self.hidden_size]   )
            __lowercase      		=ids_tensor([self.batch_size, self.seq_length]    ,   vocab_size=2   )

            return (
                config,
                input_ids,
                input_mask,
                sequence_labels,
                token_labels,
                choice_labels,
                encoder_hidden_states,
                encoder_attention_mask,
            )







       def       snake_case (				self      :			List[str]    ,   __lowercase      :			List[Any]    ,   __lowercase      :			Tuple    ,   __lowercase      :			List[Any]    ,   __lowercase      :			Optional[Any]    ,   __lowercase      :			Tuple    ,   __lowercase      :			Union[str, Any]   ):







            """simple docstring"""







            __lowercase      		=TFEsmModel(config=__lowercase   )
            __lowercase      		={'input_ids': input_ids, 'attention_mask': input_mask}
            __lowercase      		=model(__lowercase   )

            __lowercase      		=[input_ids, input_mask]
            __lowercase      		=model(__lowercase   )

            __lowercase      		=model(__lowercase   )

            self.parent.assertEqual(result.last_hidden_state.shape    ,   (self.batch_size, self.seq_length, self.hidden_size)   )







       def       snake_case (				self      :			Optional[Any]    ,   __lowercase      :			Optional[int]    ,   __lowercase      :			Any    ,   __lowercase      :			Dict    ,   __lowercase      :			Optional[Any]    ,   __lowercase      :			int    ,   __lowercase      :			Optional[Any]    ,   __lowercase      :			List[Any]    ,   __lowercase      :			List[Any]    ,   ):







            """simple docstring"""







            __lowercase      		=True

            __lowercase      		=TFEsmModel(config=__lowercase   )
            __lowercase      		={
                'input_ids': input_ids,
                'attention_mask': input_mask,
                'encoder_hidden_states': encoder_hidden_states,
                'encoder_attention_mask': encoder_attention_mask,
            }
            __lowercase      		=model(__lowercase   )

            __lowercase      		=[input_ids, input_mask]
            __lowercase      		=model(__lowercase    ,   encoder_hidden_states=__lowercase   )

            # Also check the case where encoder outputs are not passed
            __lowercase      		=model(__lowercase    ,   attention_mask=__lowercase   )

            self.parent.assertEqual(result.last_hidden_state.shape    ,   (self.batch_size, self.seq_length, self.hidden_size)   )







       def       snake_case (				self      :			Optional[int]    ,   __lowercase      :			Dict    ,   __lowercase      :			int    ,   __lowercase      :			Optional[Any]    ,   __lowercase      :			Tuple    ,   __lowercase      :			List[str]    ,   __lowercase      :			Optional[Any]   ):







            """simple docstring"""







            __lowercase      		=TFEsmForMaskedLM(config=__lowercase   )
            __lowercase      		=model([input_ids, input_mask]   )
            self.parent.assertEqual(result.logits.shape    ,   (self.batch_size, self.seq_length, self.vocab_size)   )







       def       snake_case (				self      :			int    ,   __lowercase      :			Tuple    ,   __lowercase      :			Dict    ,   __lowercase      :			Any    ,   __lowercase      :			List[str]    ,   __lowercase      :			Optional[Any]    ,   __lowercase      :			Optional[Any]   ):







            """simple docstring"""







            __lowercase      		=self.num_labels
            __lowercase      		=TFEsmForTokenClassification(config=__lowercase   )
            __lowercase      		={'input_ids': input_ids, 'attention_mask': input_mask}
            __lowercase      		=model(__lowercase   )
            self.parent.assertEqual(result.logits.shape    ,   (self.batch_size, self.seq_length, self.num_labels)   )







       def       snake_case (				self      :			Union[str, Any]   ):







            """simple docstring"""







            __lowercase      		=self.prepare_config_and_inputs()
            (
                (
                __lowercase
            )		,  (
                __lowercase
            )		,  (
                __lowercase
            )		,  (
                __lowercase
            )		,  (
                __lowercase
            )		,  (
                __lowercase
            )		,  
            )      		=config_and_inputs
            __lowercase      		={'input_ids': input_ids, 'attention_mask': input_mask}
            return config, inputs_dict






@require_tf
class 	lowerCAmelCase  (   A ,      A ,      unittest.TestCase ):
       lowerCAmelCase_												=			(
           (
               TFEsmModel,
               TFEsmForMaskedLM,
               TFEsmForSequenceClassification,
               TFEsmForTokenClassification,
           )
           if is_tf_available()
           else ()
       )
       lowerCAmelCase_												=			(
           {
               "feature-extraction": TFEsmModel,
               "fill-mask": TFEsmForMaskedLM,
               "text-classification": TFEsmForSequenceClassification,
               "token-classification": TFEsmForTokenClassification,
               "zero-shot": TFEsmForSequenceClassification,
           }
           if is_tf_available()
           else {}
       )
       lowerCAmelCase_												=			False
       lowerCAmelCase_												=			False







       def       snake_case (				self      :			str   ):







            """simple docstring"""







            __lowercase      		=TFEsmModelTester(self   )
            __lowercase      		=ConfigTester(self    ,   config_class=__lowercase    ,   hidden_size=37   )







       def       snake_case (				self      :			int   ):







            """simple docstring"""







            self.config_tester.run_common_tests()







       def       snake_case (				self      :			Dict   ):







            """simple docstring"""







            __lowercase      		=self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*__lowercase   )







       def       snake_case (				self      :			str   ):







            """simple docstring"""







            __lowercase      		=self.model_tester.prepare_config_and_inputs_for_decoder()
            self.model_tester.create_and_check_model_as_decoder(*__lowercase   )







       def       snake_case (				self      :			Tuple   ):







            """simple docstring"""







            __lowercase      		=self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_masked_lm(*__lowercase   )







       def       snake_case (				self      :			List[Any]   ):







            """simple docstring"""







            __lowercase      		=self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_token_classification(*__lowercase   )







       @slow
       def       snake_case (				self      :			str   ):







            """simple docstring"""







            for model_name in TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 __lowercase      		=TFEsmModel.from_pretrained(__lowercase   )
                 self.assertIsNotNone(__lowercase   )







       @unittest.skip('Protein models do not support embedding resizing.'   )
       def       snake_case (				self      :			Tuple   ):







            """simple docstring"""







            pass







       @unittest.skip('Protein models do not support embedding resizing.'   )
       def       snake_case (				self      :			str   ):







            """simple docstring"""







            pass







       def       snake_case (				self      :			Any   ):







            """simple docstring"""







            __lowercase		,  __lowercase      		=self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                 __lowercase      		=model_class(__lowercase   )
                 assert isinstance(model.get_input_embeddings()    ,   tf.keras.layers.Layer   )
                 if model_class is TFEsmForMaskedLM:
                      # Output embedding test differs from the main test because they're a matrix, not a layer
                      __lowercase      		=model.get_bias()
                      assert isinstance(__lowercase    ,   __lowercase   )
                      for k, v in name.items():
                           assert isinstance(__lowercase    ,   tf.Variable   )
                 else:
                      __lowercase      		=model.get_output_embeddings()
                      assert x is None
                      __lowercase      		=model.get_bias()
                      assert name is None






@require_tf
class 	lowerCAmelCase  (   unittest.TestCase ):







       @slow
       def       snake_case (				self      :			str   ):







            """simple docstring"""







            __lowercase      		=TFEsmForMaskedLM.from_pretrained('facebook/esm2_t6_8M_UR50D'   )

            __lowercase      		=tf.constant([[0, 1, 2, 3, 4, 5]]   )
            __lowercase      		=model(__lowercase   )[0]
            __lowercase      		=[1, 6, 33]
            self.assertEqual(list(output.numpy().shape   )    ,   __lowercase   )
            # compare the actual values for a slice.
            __lowercase      		=tf.constant(
                [
                    [
                        [8.9_2_1_5_1_8, -1_0.5_8_9_8_1_4, -6.4_6_7_1_3_0_7],
                        [-6.3_9_6_7_1_5_6, -1_3.9_1_1_3_7_7, -1.1_2_1_1_9_1_5],
                        [-7.7_8_1_2_4_7, -1_3.9_5_1_5_5_7, -3.7_4_0_5_9_2],
                    ]
                ]   )
            self.assertTrue(numpy.allclose(output[:, :3, :3].numpy()    ,   expected_slice.numpy()    ,   atol=1E-2   )   )







       @slow
       def       snake_case (				self      :			List[str]   ):







            """simple docstring"""







            __lowercase      		=TFEsmModel.from_pretrained('facebook/esm2_t6_8M_UR50D'   )

            __lowercase      		=tf.constant([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]]   )
            __lowercase      		=model(__lowercase   )[0]
            # compare the actual values for a slice.
            __lowercase      		=tf.constant(
                [
                    [
                        [0.1_4_4_4_3_0_9_2, 0.5_4_1_2_5_3_2_7, 0.3_2_4_7_7_3_9],
                        [0.3_0_3_4_0_4_8_4, 0.0_0_5_2_6_6_7_6, 0.3_1_0_7_7_7_2_2],
                        [0.3_2_2_7_8_0_4_3, -0.2_4_9_8_7_0_9_6, 0.3_4_1_4_6_2_8],
                    ]
                ]   )
            self.assertTrue(numpy.allclose(output[:, :3, :3].numpy()    ,   expected_slice.numpy()    ,   atol=1E-4   )   )





'''simple docstring'''

import string

def 					__UpperCamelCase				(						lowercase__    :	str			):






     '''simple docstring'''





     for key in range(len(string.ascii_uppercase			)			):
          __lowercase      		=''
          for symbol in message:
               if symbol in string.ascii_uppercase:
                    __lowercase      		=string.ascii_uppercase.find(lowercase__			)
                    __lowercase      		=num - key
                    if num < 0:
                         __lowercase      		=num + len(string.ascii_uppercase			)
                    __lowercase      		=translated + string.ascii_uppercase[num]
               else:
                    __lowercase      		=translated + symbol
          print(F'''Decryption using Key #{key}: {translated}'''			)

def 					__UpperCamelCase				(						):






     '''simple docstring'''





     __lowercase      		=input('Encrypted message: '			)
     __lowercase      		=message.upper()
     decrypt(lowercase__			)


if __name__ == "__main__":
       import doctest

       doctest.testmod()
       main()


