





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					:     int		, A					:     Dict		, )       ->Optional[Any]:
          lowerCamelCase__       :						Dict        =							parent
          lowerCamelCase__       :						Any        =							1_3
          lowerCamelCase__       :						Union[str, Any]        =							7
          lowerCamelCase__       :						int        =							True
          lowerCamelCase__       :						Dict        =							True
          lowerCamelCase__       :						Dict        =							True
          lowerCamelCase__       :						Tuple        =							9_9
          lowerCamelCase__       :						Optional[int]        =							3_2
          lowerCamelCase__       :						Dict        =							2
          lowerCamelCase__       :						Any        =							4
          lowerCamelCase__       :						Optional[Any]        =							3_7
          lowerCamelCase__       :						Dict        =							'''gelu'''
          lowerCamelCase__       :						Dict        =							0.1
          lowerCamelCase__       :						Optional[int]        =							0.1
          lowerCamelCase__       :						int        =							5_1_2
          lowerCamelCase__       :						Optional[Any]        =							1_6
          lowerCamelCase__       :						List[Any]        =							2
          lowerCamelCase__       :						Optional[Any]        =							0.02
          lowerCamelCase__       :						Dict        =							3
          lowerCamelCase__       :						Any        =							4
          lowerCamelCase__       :						Optional[Any]        =							None







       def 						__lowerCamelCase   (				self					:     Optional[int]      )       ->Any:
          lowerCamelCase__       :						Tuple        =							ids_tensor([self.batch_size, self.seq_length]		, self.vocab_size      )

          lowerCamelCase__       :						Optional[int]        =							None
          if self.use_input_mask:
             lowerCamelCase__       :						Optional[int]        =							random_attention_mask([self.batch_size, self.seq_length]      )

          lowerCamelCase__       :						List[Any]        =							None
          lowerCamelCase__       :						Dict        =							None
          lowerCamelCase__       :						List[str]        =							None
          if self.use_labels:
             lowerCamelCase__       :						Optional[Any]        =							ids_tensor([self.batch_size]		, self.type_sequence_label_size      )
             lowerCamelCase__       :						Tuple        =							ids_tensor([self.batch_size, self.seq_length]		, self.num_labels      )
             lowerCamelCase__       :						Optional[Any]        =							ids_tensor([self.batch_size]		, self.num_choices      )

          lowerCamelCase__       :						Tuple        =							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 						__lowerCamelCase   (				self					:     Union[str, Any]      )       ->Dict:
          (
              (
              lowerCamelCase__
          )       ,							(
              lowerCamelCase__
          )       ,							(
              lowerCamelCase__
          )       ,							(
              lowerCamelCase__
          )       ,							(
              lowerCamelCase__
          )       ,							(
              lowerCamelCase__
          )       ,							
          )       :						Optional[Any]        =							self.prepare_config_and_inputs()

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

          lowerCamelCase__       :						List[Any]        =							[input_ids, input_mask]
          lowerCamelCase__       :						List[str]        =							model(A      )

          lowerCamelCase__       :						Optional[int]        =							model(A      )

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







       def 						__lowerCamelCase   (				self					:     Union[str, Any]		, A					:     Optional[Any]		, A					:     Union[str, Any]		, A					:     Tuple		, A					:     Optional[Any]		, A					:     str		, A					:     int		, A					:     Optional[Any]		, A					:     Any		, )       ->List[str]:
          lowerCamelCase__       :						List[str]        =							True

          lowerCamelCase__       :						Dict        =							TFEsmModel(config=A      )
          lowerCamelCase__       :						Optional[int]        =							{
              '''input_ids''': input_ids,
              '''attention_mask''': input_mask,
              '''encoder_hidden_states''': encoder_hidden_states,
              '''encoder_attention_mask''': encoder_attention_mask,
          }
          lowerCamelCase__       :						Dict        =							model(A      )

          lowerCamelCase__       :						Optional[int]        =							[input_ids, input_mask]
          lowerCamelCase__       :						Optional[int]        =							model(A		, encoder_hidden_states=A      )

          # Also check the case where encoder outputs are not passed
          lowerCamelCase__       :						Optional[Any]        =							model(A		, attention_mask=A      )

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







       def 						__lowerCamelCase   (				self					:     Optional[Any]		, A					:     List[Any]		, A					:     Optional[Any]		, A					:     Any		, A					:     Optional[int]		, A					:     int		, A					:     List[str]      )       ->int:
          lowerCamelCase__       :						Tuple        =							TFEsmForMaskedLM(config=A      )
          lowerCamelCase__       :						int        =							model([input_ids, input_mask]      )
          self.parent.assertEqual(result.logits.shape		, (self.batch_size, self.seq_length, self.vocab_size)      )







       def 						__lowerCamelCase   (				self					:     List[Any]		, A					:     Tuple		, A					:     List[Any]		, A					:     Tuple		, A					:     Union[str, Any]		, A					:     str		, A					:     str      )       ->Dict:
          lowerCamelCase__       :						Optional[Any]        =							self.num_labels
          lowerCamelCase__       :						List[Any]        =							TFEsmForTokenClassification(config=A      )
          lowerCamelCase__       :						Any        =							{'''input_ids''': input_ids, '''attention_mask''': input_mask}
          lowerCamelCase__       :						Union[str, Any]        =							model(A      )
          self.parent.assertEqual(result.logits.shape		, (self.batch_size, self.seq_length, self.num_labels)      )







       def 						__lowerCamelCase   (				self					:     List[Any]      )       ->Union[str, Any]:
          lowerCamelCase__       :						int        =							self.prepare_config_and_inputs()
          (
              (
              lowerCamelCase__
          )       ,							(
              lowerCamelCase__
          )       ,							(
              lowerCamelCase__
          )       ,							(
              lowerCamelCase__
          )       ,							(
              lowerCamelCase__
          )       ,							(
              lowerCamelCase__
          )       ,							
          )       :						List[Any]        =							config_and_inputs
          lowerCamelCase__       :						Union[str, Any]        =							{'''input_ids''': input_ids, '''attention_mask''': input_mask}
          return config, inputs_dict


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







       def 						__lowerCamelCase   (				self					:     Optional[Any]      )       ->List[str]:
          lowerCamelCase__       :						str        =							TFEsmModelTester(self      )
          lowerCamelCase__       :						str        =							ConfigTester(self		, config_class=A		, hidden_size=3_7      )







       def 						__lowerCamelCase   (				self					:     Optional[Any]      )       ->str:
          self.config_tester.run_common_tests()







       def 						__lowerCamelCase   (				self					:     Union[str, Any]      )       ->Optional[int]:
          lowerCamelCase__       :						List[Any]        =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*A      )







       def 						__lowerCamelCase   (				self					:     str      )       ->Any:
          lowerCamelCase__       :						Optional[Any]        =							self.model_tester.prepare_config_and_inputs_for_decoder()
          self.model_tester.create_and_check_model_as_decoder(*A      )







       def 						__lowerCamelCase   (				self					:     Tuple      )       ->int:
          lowerCamelCase__       :						str        =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_masked_lm(*A      )







       def 						__lowerCamelCase   (				self					:     Optional[int]      )       ->Optional[Any]:
          lowerCamelCase__       :						List[str]        =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_token_classification(*A      )







       @slow
       def 						__lowerCamelCase   (				self					:     Dict      )       ->List[Any]:
          for model_name in TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             lowerCamelCase__       :						Any        =							TFEsmModel.from_pretrained(A      )
             self.assertIsNotNone(A      )







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







       @unittest.skip('''Protein models do not support embedding resizing.'''      )
       def 						__lowerCamelCase   (				self					:     Dict      )       ->Optional[Any]:
          pass







       def 						__lowerCamelCase   (				self					:     Union[str, Any]      )       ->List[Any]:
          lowerCamelCase__       ,							lowerCamelCase__       :						Union[str, Any]        =							self.model_tester.prepare_config_and_inputs_for_common()

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


@require_tf
class        __SCREAMING_SNAKE_CASE      (			unittest.TestCase ):







       @slow
       def 						__lowerCamelCase   (				self					:     Tuple      )       ->str:
          lowerCamelCase__       :						Dict        =							TFEsmForMaskedLM.from_pretrained('''facebook/esm2_t6_8M_UR50D'''      )

          lowerCamelCase__       :						List[Any]        =							tf.constant([[0, 1, 2, 3, 4, 5]]      )
          lowerCamelCase__       :						Any        =							model(A      )[0]
          lowerCamelCase__       :						int        =							[1, 6, 3_3]
          self.assertEqual(list(output.numpy().shape      )		, A      )
          # compare the actual values for a slice.
          lowerCamelCase__       :						Union[str, Any]        =							tf.constant(
              [
                  [
                      [8.92_15_18, -10.58_98_14, -6.4_67_13_07],
                      [-6.3_96_71_56, -13.91_13_77, -1.1_21_19_15],
                      [-7.78_12_47, -13.95_15_57, -3.74_05_92],
                  ]
              ]      )
          self.assertTrue(numpy.allclose(output[:, :3, :3].numpy()		, expected_slice.numpy()		, atol=1e-2      )      )







       @slow
       def 						__lowerCamelCase   (				self					:     Tuple      )       ->Union[str, Any]:
          lowerCamelCase__       :						int        =							TFEsmModel.from_pretrained('''facebook/esm2_t6_8M_UR50D'''      )

          lowerCamelCase__       :						Optional[Any]        =							tf.constant([[0, 6, 4, 1_3, 5, 4, 1_6, 1_2, 1_1, 7, 2]]      )
          lowerCamelCase__       :						List[Any]        =							model(A      )[0]
          # compare the actual values for a slice.
          lowerCamelCase__       :						Union[str, Any]        =							tf.constant(
              [
                  [
                      [0.14_44_30_92, 0.54_12_53_27, 0.3_24_77_39],
                      [0.30_34_04_84, 0.00_52_66_76, 0.31_07_77_22],
                      [0.32_27_80_43, -0.24_98_70_96, 0.3_41_46_28],
                  ]
              ]      )
          self.assertTrue(numpy.allclose(output[:, :3, :3].numpy()		, expected_slice.numpy()		, atol=1e-4      )      )










import pprint

import requests

_A :   Any  			=  'https://zenquotes.io/api'



def 	_a						(   )    ->    list:







   """simple docstring"""
   return requests.get(API_ENDPOINT_URL + '''/today'''					).json()



def 	_a						(   )    ->    list:







   """simple docstring"""
   return requests.get(API_ENDPOINT_URL + '''/random'''					).json()


if __name__ == "__main__":
       _A :   Optional[Any]  			=  random_quotes()
       pprint.pprint(response)



