



"""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      UpperCAmelCase__		:



  def __init__( self  :    Union[str, Any]      ,							snake_case  :    Dict      ,							)			->						Union[str, Any]:






         '''simple docstring'''

         A         =					parent
         A         =					13
         A         =					7
         A         =					True
         A         =					True
         A         =					True
         A         =					99
         A         =					32
         A         =					2
         A         =					4
         A         =					37
         A         =					"gelu"
         A         =					0.1
         A         =					0.1
         A         =					512
         A         =					16
         A         =					2
         A         =					0.02
         A         =					3
         A         =					4
         A         =					None



  def 					A_		( self  :    Union[str, Any]				)			->						Dict:






         '''simple docstring'''

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

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

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

         A         =					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 					A_		( self  :    Tuple				)			->						Any:






         '''simple docstring'''

         (
             A 
         )         =					self.prepare_config_and_inputs()

         A         =					True
         A         =					floats_tensor([self.batch_size, self.seq_length, self.hidden_size]				)
         A         =					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 					A_		( self  :    Tuple      ,							snake_case  :    Optional[int]      ,							snake_case  :    Dict      ,							snake_case  :    Union[str, Any]      ,							snake_case  :    List[Any]      ,							snake_case  :    List[str]      ,							snake_case  :    Tuple				)			->						int:






         '''simple docstring'''

         A         =					TFEsmModel(config=UpperCamelCase_				)
         A         =					{"input_ids": input_ids, "attention_mask": input_mask}
         A         =					model(UpperCamelCase_				)

         A         =					[input_ids, input_mask]
         A         =					model(UpperCamelCase_				)

         A         =					model(UpperCamelCase_				)

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



  def 					A_		( self  :    Any      ,							snake_case  :    int      ,							snake_case  :    Tuple      ,							snake_case  :    Optional[Any]      ,							snake_case  :    Tuple      ,							snake_case  :    Tuple      ,							snake_case  :    Dict      ,							snake_case  :    int      ,							snake_case  :    Tuple      ,							)			->						Any:






         '''simple docstring'''

         A         =					True

         A         =					TFEsmModel(config=UpperCamelCase_				)
         A         =					{
             "input_ids": input_ids,
             "attention_mask": input_mask,
             "encoder_hidden_states": encoder_hidden_states,
             "encoder_attention_mask": encoder_attention_mask,
         }
         A         =					model(UpperCamelCase_				)

         A         =					[input_ids, input_mask]
         A         =					model(UpperCamelCase_      ,							encoder_hidden_states=UpperCamelCase_				)

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

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



  def 					A_		( self  :    Union[str, Any]      ,							snake_case  :    Optional[Any]      ,							snake_case  :    Optional[int]      ,							snake_case  :    Any      ,							snake_case  :    int      ,							snake_case  :    int      ,							snake_case  :    Dict				)			->						Any:






         '''simple docstring'''

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



  def 					A_		( self  :    List[Any]      ,							snake_case  :    List[Any]      ,							snake_case  :    List[str]      ,							snake_case  :    Optional[Any]      ,							snake_case  :    Union[str, Any]      ,							snake_case  :    List[Any]      ,							snake_case  :    Any				)			->						Optional[int]:






         '''simple docstring'''

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



  def 					A_		( self  :    Optional[Any]				)			->						Any:






         '''simple docstring'''

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






@require_tf
class      UpperCAmelCase__		(      UpperCamelCase   ,UpperCamelCase   ,unittest.TestCase     ):
  lowerCAmelCase_       :	Optional[int] 							=     (
      (
          TFEsmModel,
          TFEsmForMaskedLM,
          TFEsmForSequenceClassification,
          TFEsmForTokenClassification,
      )
      if is_tf_available()
      else ()
  )
  lowerCAmelCase_       :	List[str] 							=     (
      {
          "feature-extraction": TFEsmModel,
          "fill-mask": TFEsmForMaskedLM,
          "text-classification": TFEsmForSequenceClassification,
          "token-classification": TFEsmForTokenClassification,
          "zero-shot": TFEsmForSequenceClassification,
      }
      if is_tf_available()
      else {}
  )
  lowerCAmelCase_       :	Tuple 							=     False
  lowerCAmelCase_       :	Any 							=     False



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






         '''simple docstring'''

         A         =					TFEsmModelTester(self				)
         A         =					ConfigTester(self      ,							config_class=UpperCamelCase_      ,							hidden_size=37				)



  def 					A_		( self  :    Optional[int]				)			->						int:






         '''simple docstring'''

         self.config_tester.run_common_tests()



  def 					A_		( self  :    int				)			->						Optional[int]:






         '''simple docstring'''

         A         =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*UpperCamelCase_				)



  def 					A_		( self  :    Any				)			->						Dict:






         '''simple docstring'''

         A         =					self.model_tester.prepare_config_and_inputs_for_decoder()
         self.model_tester.create_and_check_model_as_decoder(*UpperCamelCase_				)



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






         '''simple docstring'''

         A         =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_lm(*UpperCamelCase_				)



  def 					A_		( self  :    Dict				)			->						Any:






         '''simple docstring'''

         A         =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*UpperCamelCase_				)



  @slow
  def 					A_		( self  :    Union[str, Any]				)			->						Any:






         '''simple docstring'''

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



  @unittest.skip('Protein models do not support embedding resizing.'				)
  def 					A_		( self  :    int				)			->						str:






         '''simple docstring'''

         pass



  @unittest.skip('Protein models do not support embedding resizing.'				)
  def 					A_		( self  :    str				)			->						List[str]:






         '''simple docstring'''

         pass



  def 					A_		( self  :    int				)			->						Any:






         '''simple docstring'''

         A         =					self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
                A         =					model_class(UpperCamelCase_				)
                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
                       A         =					model.get_bias()
                       assert isinstance(UpperCamelCase_      ,							UpperCamelCase_				)
                       for k, v in name.items():
                              assert isinstance(UpperCamelCase_      ,							tf.Variable				)
                else:
                       A         =					model.get_output_embeddings()
                       assert x is None
                       A         =					model.get_bias()
                       assert name is None






@require_tf
class      UpperCAmelCase__		(      unittest.TestCase     ):



  @slow
  def 					A_		( self  :    Dict				)			->						int:






         '''simple docstring'''

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

         A         =					tf.constant([[0, 1, 2, 3, 4, 5]]				)
         A         =					model(UpperCamelCase_				)[0]
         A         =					[1, 6, 33]
         self.assertEqual(list(output.numpy().shape				)      ,							UpperCamelCase_				)
         # compare the actual values for a slice.
         A         =					tf.constant(
             [
                 [
                     [8.921518, -10.589_814, -6.4671307],
                     [-6.3967156, -13.911_377, -1.1211915],
                     [-7.781247, -13.951_557, -3.740592],
                 ]
             ]				)
         self.assertTrue(numpy.allclose(output[:, :3, :3].numpy()      ,							expected_slice.numpy()      ,							atol=1E-2				)				)



  @slow
  def 					A_		( self  :    Tuple				)			->						List[str]:






         '''simple docstring'''

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

         A         =					tf.constant([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]]				)
         A         =					model(UpperCamelCase_				)[0]
         # compare the actual values for a slice.
         A         =					tf.constant(
             [
                 [
                     [0.14443092, 0.54125327, 0.3247739],
                     [0.30340484, 0.00526676, 0.31077722],
                     [0.32278043, -0.24987096, 0.3414628],
                 ]
             ]				)
         self.assertTrue(numpy.allclose(output[:, :3, :3].numpy()      ,							expected_slice.numpy()      ,							atol=1E-4				)				)








"""simple docstring"""







import re

def   lowerCAmelCase__			(     lowerCamelCase__			) ->							list:
							return [char.split() for char in re.split(R'[^ a-z A-Z 0-9 \s]'				,      str_			)]

def   lowerCAmelCase__			(     lowerCamelCase__			) ->							str:
							A         =					split_input(str_			)
							return "".join(
							    [''.join([char.capitalize() for char in sub_str]			) for sub_str in string_split]			)

def   lowerCAmelCase__			(     lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__			) ->							str:
							try:
														A         =					split_input(lowerCamelCase__			)
														if upper:
																					A         =					''.join(
																					    [
																					        separator.join([char.upper() for char in sub_str]			)
																					        for sub_str in string_split
																					    ]			)
														else:
																					A         =					''.join(
																					    [
																					        separator.join([char.lower() for char in sub_str]			)
																					        for sub_str in string_split
																					    ]			)
														return res_str
							except IndexError:
														return "not valid string"

def   lowerCAmelCase__			(     lowerCamelCase__			) ->							str:
							return to_simple_case(lowerCamelCase__			)

def   lowerCAmelCase__			(     lowerCamelCase__			) ->							str:
							try:
														A         =					to_simple_case(lowerCamelCase__			)
														return res_str[0].lower() + res_str[1:]
							except IndexError:
														return "not valid string"

def   lowerCAmelCase__			(     lowerCamelCase__				,      lowerCamelCase__			) ->							str:
							return to_complex_case(lowerCamelCase__				,      lowerCamelCase__				,      '_'			)

def   lowerCAmelCase__			(     lowerCamelCase__				,      lowerCamelCase__			) ->							str:
							return to_complex_case(lowerCamelCase__				,      lowerCamelCase__				,      '-'			)


if __name__ == "__main__":
							__import__('doctest').testmod()



