

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





    def __init__(      self						,   a						,   ):
         lowercase__    :   Any      =       parent
         lowercase__    :   List[Any]      =       13
         lowercase__    :   List[str]      =       7
         lowercase__    :   List[str]      =       True
         lowercase__    :   Tuple      =       True
         lowercase__    :   Dict      =       True
         lowercase__    :   str      =       99
         lowercase__    :   str      =       32
         lowercase__    :   Union[str, Any]      =       2
         lowercase__    :   Dict      =       4
         lowercase__    :   Tuple      =       37
         lowercase__    :   Optional[int]      =       'gelu'
         lowercase__    :   Any      =       0.1
         lowercase__    :   Optional[Any]      =       0.1
         lowercase__    :   Dict      =       512
         lowercase__    :   Tuple      =       16
         lowercase__    :   Dict      =       2
         lowercase__    :   Tuple      =       0.02
         lowercase__    :   Optional[Any]      =       3
         lowercase__    :   Optional[Any]      =       4
         lowercase__    :   str      =       None





    def       snake_case_				(      self):
         lowercase__    :   Any      =       ids_tensor([self.batch_size, self.seq_length]						,   self.vocab_size)

         lowercase__    :   Tuple      =       None
         if self.use_input_mask:
              lowercase__    :   str      =       random_attention_mask([self.batch_size, self.seq_length])

         lowercase__    :   List[Any]      =       None
         lowercase__    :   List[str]      =       None
         lowercase__    :   Any      =       None
         if self.use_labels:
              lowercase__    :   Union[str, Any]      =       ids_tensor([self.batch_size]						,   self.type_sequence_label_size)
              lowercase__    :   Union[str, Any]      =       ids_tensor([self.batch_size, self.seq_length]						,   self.num_labels)
              lowercase__    :   Optional[int]      =       ids_tensor([self.batch_size]						,   self.num_choices)

         lowercase__    :   List[str]      =       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):
         (
             (
             lowercase__
         )      , (
             lowercase__
         )      , (
             lowercase__
         )      , (
             lowercase__
         )      , (
             lowercase__
         )      , (
             lowercase__
         )      , 
         )    :   Dict      =       self.prepare_config_and_inputs()

         lowercase__    :   List[Any]      =       True
         lowercase__    :   Union[str, Any]      =       floats_tensor([self.batch_size, self.seq_length, self.hidden_size])
         lowercase__    :   int      =       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						,   a						,   a						,   a						,   a						,   a						,   a):
         lowercase__    :   Optional[Any]      =       TFEsmModel(config=a)
         lowercase__    :   List[Any]      =       {'input_ids': input_ids, 'attention_mask': input_mask}
         lowercase__    :   List[Any]      =       model(a)

         lowercase__    :   Tuple      =       [input_ids, input_mask]
         lowercase__    :   Any      =       model(a)

         lowercase__    :   Any      =       model(a)

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





    def       snake_case_				(      self						,   a						,   a						,   a						,   a						,   a						,   a						,   a						,   a						,   ):
         lowercase__    :   str      =       True

         lowercase__    :   Tuple      =       TFEsmModel(config=a)
         lowercase__    :   str      =       {
             'input_ids': input_ids,
             'attention_mask': input_mask,
             'encoder_hidden_states': encoder_hidden_states,
             'encoder_attention_mask': encoder_attention_mask,
         }
         lowercase__    :   List[Any]      =       model(a)

         lowercase__    :   Optional[Any]      =       [input_ids, input_mask]
         lowercase__    :   Optional[int]      =       model(a						,   encoder_hidden_states=a)

         # Also check the case where encoder outputs are not passed
         lowercase__    :   List[str]      =       model(a						,   attention_mask=a)

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





    def       snake_case_				(      self						,   a						,   a						,   a						,   a						,   a						,   a):
         lowercase__    :   Union[str, Any]      =       TFEsmForMaskedLM(config=a)
         lowercase__    :   Optional[int]      =       model([input_ids, input_mask])
         self.parent.assertEqual(result.logits.shape						,   (self.batch_size, self.seq_length, self.vocab_size))





    def       snake_case_				(      self						,   a						,   a						,   a						,   a						,   a						,   a):
         lowercase__    :   str      =       self.num_labels
         lowercase__    :   str      =       TFEsmForTokenClassification(config=a)
         lowercase__    :   Optional[int]      =       {'input_ids': input_ids, 'attention_mask': input_mask}
         lowercase__    :   Dict      =       model(a)
         self.parent.assertEqual(result.logits.shape						,   (self.batch_size, self.seq_length, self.num_labels))





    def       snake_case_				(      self):
         lowercase__    :   List[str]      =       self.prepare_config_and_inputs()
         (
             (
             lowercase__
         )      , (
             lowercase__
         )      , (
             lowercase__
         )      , (
             lowercase__
         )      , (
             lowercase__
         )      , (
             lowercase__
         )      , 
         )    :   Union[str, Any]      =       config_and_inputs
         lowercase__    :   Tuple      =       {'input_ids': input_ids, 'attention_mask': input_mask}
         return config, inputs_dict



@require_tf
class       SCREAMING_SNAKE_CASE__					(__snake_case		,       __snake_case		,       unittest.TestCase     ):
    __lowerCamelCase						:       Optional[Any]														=     (
        (
            TFEsmModel,
            TFEsmForMaskedLM,
            TFEsmForSequenceClassification,
            TFEsmForTokenClassification,
        )
        if is_tf_available()
        else ()
    )
    __lowerCamelCase						:       List[Any]														=     (
        {
            """feature-extraction""": TFEsmModel,
            """fill-mask""": TFEsmForMaskedLM,
            """text-classification""": TFEsmForSequenceClassification,
            """token-classification""": TFEsmForTokenClassification,
            """zero-shot""": TFEsmForSequenceClassification,
        }
        if is_tf_available()
        else {}
    )
    __lowerCamelCase						:       Dict														=     False
    __lowerCamelCase						:       Any														=     False





    def       snake_case_				(      self):
         lowercase__    :   int      =       TFEsmModelTester(self)
         lowercase__    :   Union[str, Any]      =       ConfigTester(self						,   config_class=a						,   hidden_size=37)





    def       snake_case_				(      self):
         self.config_tester.run_common_tests()





    def       snake_case_				(      self):
         lowercase__    :   str      =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*a)





    def       snake_case_				(      self):
         lowercase__    :   Optional[Any]      =       self.model_tester.prepare_config_and_inputs_for_decoder()
         self.model_tester.create_and_check_model_as_decoder(*a)





    def       snake_case_				(      self):
         lowercase__    :   Any      =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_lm(*a)





    def       snake_case_				(      self):
         lowercase__    :   Dict      =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*a)





    @slow
    def       snake_case_				(      self):
         for model_name in TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              lowercase__    :   Optional[int]      =       TFEsmModel.from_pretrained(a)
              self.assertIsNotNone(a)





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





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





    def       snake_case_				(      self):
         lowercase__      , lowercase__    :   int      =       self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
              lowercase__    :   Union[str, Any]      =       model_class(a)
              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__    :   Optional[Any]      =       model.get_bias()
                   assert isinstance(a						,   a)
                   for k, v in name.items():
                        assert isinstance(a						,   tf.Variable)
              else:
                   lowercase__    :   str      =       model.get_output_embeddings()
                   assert x is None
                   lowercase__    :   Union[str, Any]      =       model.get_bias()
                   assert name is None



@require_tf
class       SCREAMING_SNAKE_CASE__					(unittest.TestCase     ):





    @slow
    def       snake_case_				(      self):
         lowercase__    :   Tuple      =       TFEsmForMaskedLM.from_pretrained('facebook/esm2_t6_8M_UR50D')

         lowercase__    :   Dict      =       tf.constant([[0, 1, 2, 3, 4, 5]])
         lowercase__    :   str      =       model(a)[0]
         lowercase__    :   List[Any]      =       [1, 6, 33]
         self.assertEqual(list(output.numpy().shape)						,   a)
         # compare the actual values for a slice.
         lowercase__    :   Optional[Any]      =       tf.constant(
             [
                 [
                     [8.921_518, -10.589_814, -6.4_671_307],
                     [-6.3_967_156, -13.911_377, -1.1_211_915],
                     [-7.781_247, -13.951_557, -3.740_592],
                 ]
             ])
         self.assertTrue(numpy.allclose(output[:, :3, :3].numpy()						,   expected_slice.numpy()						,   atol=1e-2))





    @slow
    def       snake_case_				(      self):
         lowercase__    :   str      =       TFEsmModel.from_pretrained('facebook/esm2_t6_8M_UR50D')

         lowercase__    :   int      =       tf.constant([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]])
         lowercase__    :   Optional[Any]      =       model(a)[0]
         # compare the actual values for a slice.
         lowercase__    :   int      =       tf.constant(
             [
                 [
                     [0.14_443_092, 0.54_125_327, 0.3_247_739],
                     [0.30_340_484, 0.00_526_676, 0.31_077_722],
                     [0.32_278_043, -0.24_987_096, 0.3_414_628],
                 ]
             ])
         self.assertTrue(numpy.allclose(output[:, :3, :3].numpy()						,   expected_slice.numpy()						,   atol=1e-4))




def 	snake_case__			(    SCREAMING_SNAKE_CASE_		:    str			):



     '''simple docstring'''





     if not all(x.isalpha() for x in string			):
          raise ValueError('String must only contain alphabetic characters.'			)

     lowercase__    :   Optional[int]      =       sorted(string.lower()			)
     return len(SCREAMING_SNAKE_CASE_			) == len(set(SCREAMING_SNAKE_CASE_			)			)


if __name__ == "__main__":
       snake_case_			  = input('''Enter a string ''').strip()

       snake_case_			  = is_isogram(input_str)
       print(F'''{input_str} is {'an' if isogram else 'not an'} isogram.''')

