




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

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

     def       a__			(						self       )		->							str:
           _A							:  Dict    =		ids_tensor([self.batch_size, self.seq_length]	,  self.vocab_size       )

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

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

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

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

           _A							:  Optional[Any]    =		[input_ids, input_mask]
           _A							:  int    =		model(lowerCamelCase_       )

           _A							:  Optional[int]    =		model(lowerCamelCase_       )

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

     def       a__			(						self	,  _a	,  _a	,  _a	,  _a	,  _a	,  _a	,  _a	,  _a	,  )		->							str:
           _A							:  Dict    =		True

           _A							:  Tuple    =		TFEsmModel(config=lowerCamelCase_       )
           _A							:  Dict    =		{
               '''input_ids''': input_ids,
               '''attention_mask''': input_mask,
               '''encoder_hidden_states''': encoder_hidden_states,
               '''encoder_attention_mask''': encoder_attention_mask,
           }
           _A							:  Any    =		model(lowerCamelCase_       )

           _A							:  List[str]    =		[input_ids, input_mask]
           _A							:  Any    =		model(lowerCamelCase_	,  encoder_hidden_states=lowerCamelCase_       )

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

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

     def       a__			(						self	,  _a	,  _a	,  _a	,  _a	,  _a	,  _a       )		->							Any:
           _A							:  int    =		TFEsmForMaskedLM(config=lowerCamelCase_       )
           _A							:  Optional[int]    =		model([input_ids, input_mask]       )
           self.parent.assertEqual(result.logits.shape	,  (self.batch_size, self.seq_length, self.vocab_size)       )

     def       a__			(						self	,  _a	,  _a	,  _a	,  _a	,  _a	,  _a       )		->							int:
           _A							:  List[Any]    =		self.num_labels
           _A							:  List[Any]    =		TFEsmForTokenClassification(config=lowerCamelCase_       )
           _A							:  Optional[int]    =		{'''input_ids''': input_ids, '''attention_mask''': input_mask}
           _A							:  Union[str, Any]    =		model(lowerCamelCase_       )
           self.parent.assertEqual(result.logits.shape	,  (self.batch_size, self.seq_length, self.num_labels)       )



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







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

     def       a__			(						self       )		->							Dict:
           _A							:  List[str]    =		TFEsmModelTester(self       )
           _A							:  Any    =		ConfigTester(self	,  config_class=lowerCamelCase_	,  hidden_size=37       )

     def       a__			(						self       )		->							str:
           self.config_tester.run_common_tests()

     def       a__			(						self       )		->							Optional[int]:
           _A							:  Optional[Any]    =		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*lowerCamelCase_       )

     def       a__			(						self       )		->							List[str]:
           _A							:  Dict    =		self.model_tester.prepare_config_and_inputs_for_decoder()
           self.model_tester.create_and_check_model_as_decoder(*lowerCamelCase_       )

     def       a__			(						self       )		->							Optional[Any]:
           _A							:  List[Any]    =		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_masked_lm(*lowerCamelCase_       )

     def       a__			(						self       )		->							Optional[Any]:
           _A							:  str    =		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_token_classification(*lowerCamelCase_       )

     @slow
     def       a__			(						self       )		->							str:




           for model_name in TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 _A							:  List[Any]    =		TFEsmModel.from_pretrained(lowerCamelCase_       )
                 self.assertIsNotNone(lowerCamelCase_       )

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

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



     def       a__			(						self       )		->							List[Any]:
           _A							:  Tuple    =		self.model_tester.prepare_config_and_inputs_for_common()

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







@require_tf
class 		lowercase							(     unittest.TestCase	):

     @slow
     def       a__			(						self       )		->							Optional[Any]:
           _A							:  int    =		TFEsmForMaskedLM.from_pretrained("""facebook/esm2_t6_8M_UR50D"""       )

           _A							:  Tuple    =		tf.constant([[0, 1, 2, 3, 4, 5]]       )
           _A							:  Tuple    =		model(lowerCamelCase_       )[0]
           _A							:  Any    =		[1, 6, 33]
           self.assertEqual(list(output.numpy().shape       )	,  lowerCamelCase_       )
           # compare the actual values for a slice.
           _A							:  Optional[Any]    =		tf.constant(
               [
                   [
                       [8.921518, -10.58_9814, -6.4671307],
                       [-6.3967156, -13.91_1377, -1.1211915],
                       [-7.781247, -13.95_1557, -3.740592],
                   ]
               ]       )
           self.assertTrue(numpy.allclose(output[:, :3, :3].numpy()	,  expected_slice.numpy()	,  atol=1e-2       )       )



     @slow
     def       a__			(						self       )		->							List[str]:
           _A							:  Tuple    =		TFEsmModel.from_pretrained("""facebook/esm2_t6_8M_UR50D"""       )

           _A							:  List[str]    =		tf.constant([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]]       )
           _A							:  Union[str, Any]    =		model(lowerCamelCase_       )[0]
           # compare the actual values for a slice.
           _A							:  Any    =		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       )       )







from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_torch_available,
    is_vision_available,
)


_snake_case            = {
    "configuration_efficientformer": [
        "EFFICIENTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "EfficientFormerConfig",
    ]
}

try:
  if not is_vision_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _snake_case            = ["EfficientFormerImageProcessor"]

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _snake_case            = [
      "EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST",
      "EfficientFormerForImageClassification",
      "EfficientFormerForImageClassificationWithTeacher",
      "EfficientFormerModel",
      "EfficientFormerPreTrainedModel",
  ]

try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _snake_case            = [
      "TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST",
      "TFEfficientFormerForImageClassification",
      "TFEfficientFormerForImageClassificationWithTeacher",
      "TFEfficientFormerModel",
      "TFEfficientFormerPreTrainedModel",
  ]

if TYPE_CHECKING:
  from .configuration_efficientformer import EFFICIENTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, EfficientFormerConfig

  try:
    if not is_vision_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .image_processing_efficientformer import EfficientFormerImageProcessor

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_efficientformer import (
        EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
        EfficientFormerForImageClassification,
        EfficientFormerForImageClassificationWithTeacher,
        EfficientFormerModel,
        EfficientFormerPreTrainedModel,
    )
  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_efficientformer import (
        TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFEfficientFormerForImageClassification,
        TFEfficientFormerForImageClassificationWithTeacher,
        TFEfficientFormerModel,
        TFEfficientFormerPreTrainedModel,
    )

else:
  import sys

  _snake_case            = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)

