


'''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 						A__							:




						def __init__(       self					:      Dict				,    _a					:      List[str]				,    )							->     Optional[int]:


										"""simple docstring"""





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




						def 							__UpperCamelCase				(       self					:      int  )							->     Any:


										"""simple docstring"""





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

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

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

										_SCREAMING_SNAKE_CASE			  =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 							__UpperCamelCase				(       self					:      int  )							->     List[Any]:


										"""simple docstring"""





										(
										    _SCREAMING_SNAKE_CASE 
										)			  =self.prepare_config_and_inputs()

										_SCREAMING_SNAKE_CASE			  =True
										_SCREAMING_SNAKE_CASE			  =floats_tensor([self.batch_size, self.seq_length, self.hidden_size]  )
										_SCREAMING_SNAKE_CASE			  =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 							__UpperCamelCase				(       self					:      List[Any]				,    _a					:      str				,    _a					:      str				,    _a					:      Tuple				,    _a					:      Tuple				,    _a					:      List[Any]				,    _a					:      Optional[int]  )							->     Optional[Any]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =TFEsmModel(config=__lowerCamelCase  )
										_SCREAMING_SNAKE_CASE			  ={"input_ids": input_ids, "attention_mask": input_mask}
										_SCREAMING_SNAKE_CASE			  =model(__lowerCamelCase  )

										_SCREAMING_SNAKE_CASE			  =[input_ids, input_mask]
										_SCREAMING_SNAKE_CASE			  =model(__lowerCamelCase  )

										_SCREAMING_SNAKE_CASE			  =model(__lowerCamelCase  )

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




						def 							__UpperCamelCase				(       self					:      List[str]				,    _a					:      List[str]				,    _a					:      Dict				,    _a					:      int				,    _a					:      str				,    _a					:      List[str]				,    _a					:      Optional[Any]				,    _a					:      Tuple				,    _a					:      List[str]				,    )							->     List[Any]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =True

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

										_SCREAMING_SNAKE_CASE			  =[input_ids, input_mask]
										_SCREAMING_SNAKE_CASE			  =model(__lowerCamelCase				,    encoder_hidden_states=__lowerCamelCase  )

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

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




						def 							__UpperCamelCase				(       self					:      str				,    _a					:      Union[str, Any]				,    _a					:      Optional[Any]				,    _a					:      Dict				,    _a					:      Union[str, Any]				,    _a					:      Union[str, Any]				,    _a					:      Union[str, Any]  )							->     Dict:


										"""simple docstring"""





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




						def 							__UpperCamelCase				(       self					:      List[Any]				,    _a					:      Dict				,    _a					:      str				,    _a					:      Tuple				,    _a					:      Optional[int]				,    _a					:      int				,    _a					:      int  )							->     int:


										"""simple docstring"""





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




						def 							__UpperCamelCase				(       self					:      Dict  )							->     int:


										"""simple docstring"""





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

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




						def 							__UpperCamelCase				(       self					:      int  )							->     Optional[Any]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =TFEsmModelTester(self  )
										_SCREAMING_SNAKE_CASE			  =ConfigTester(self				,    config_class=__lowerCamelCase				,    hidden_size=37  )




						def 							__UpperCamelCase				(       self					:      List[str]  )							->     Dict:


										"""simple docstring"""





										self.config_tester.run_common_tests()




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


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*__lowerCamelCase  )




						def 							__UpperCamelCase				(       self					:      Optional[int]  )							->     Optional[Any]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.model_tester.prepare_config_and_inputs_for_decoder()
										self.model_tester.create_and_check_model_as_decoder(*__lowerCamelCase  )




						def 							__UpperCamelCase				(       self					:      int  )							->     str:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_lm(*__lowerCamelCase  )




						def 							__UpperCamelCase				(       self					:      Optional[Any]  )							->     List[Any]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_token_classification(*__lowerCamelCase  )




						@slow
						def 							__UpperCamelCase				(       self					:      str  )							->     int:


										"""simple docstring"""





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




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


										"""simple docstring"""





										pass




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


										"""simple docstring"""





										pass




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


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.model_tester.prepare_config_and_inputs_for_common()

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

@require_tf
class 						A__							(		unittest.TestCase  ):




						@slow
						def 							__UpperCamelCase				(       self					:      Union[str, Any]  )							->     Optional[int]:


										"""simple docstring"""





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

										_SCREAMING_SNAKE_CASE			  =tf.constant([[0, 1, 2, 3, 4, 5]]  )
										_SCREAMING_SNAKE_CASE			  =model(__lowerCamelCase  )[0]
										_SCREAMING_SNAKE_CASE			  =[1, 6, 33]
										self.assertEqual(list(output.numpy().shape  )				,    __lowerCamelCase  )
										# compare the actual values for a slice.
										_SCREAMING_SNAKE_CASE			  =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 							__UpperCamelCase				(       self					:      Optional[int]  )							->     int:


										"""simple docstring"""





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

										_SCREAMING_SNAKE_CASE			  =tf.constant([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]]  )
										_SCREAMING_SNAKE_CASE			  =model(__lowerCamelCase  )[0]
										# compare the actual values for a slice.
										_SCREAMING_SNAKE_CASE			  =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 warnings

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding

class 						A__							(		UpperCamelCase__  ):
						UpperCAmelCase             =						["image_processor", "tokenizer"]
						UpperCAmelCase             =						"ViTImageProcessor"
						UpperCAmelCase             =						("CLIPTokenizer", "CLIPTokenizerFast")




						def __init__(       self					:      int				,    _a					:      int=None				,    _a					:      Optional[int]=None				,    **_a					:      str  )							->     List[str]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =None
										if "feature_extractor" in kwargs:
														warnings.warn(
														    '''The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'''
														    ''' instead.'''				,    _a				,    )
														_SCREAMING_SNAKE_CASE			  =kwargs.pop('''feature_extractor'''  )

										_SCREAMING_SNAKE_CASE			  =image_processor if image_processor is not None else feature_extractor
										if image_processor is None:
														raise ValueError('''You need to specify an `image_processor`.'''  )
										if tokenizer is None:
														raise ValueError('''You need to specify a `tokenizer`.'''  )

										super().__init__(_a				,    _a  )




						def __call__(       self					:      List[str]				,    _a					:      Tuple=None				,    _a					:      Optional[Any]=None				,    _a					:      List[Any]=None				,    _a					:      List[Any]=None				,    **_a					:      List[Any]  )							->     Optional[Any]:


										"""simple docstring"""





										if text is None and visual_prompt is None and images is None:
														raise ValueError('''You have to specify either text, visual prompt or images.'''  )

										if text is not None and visual_prompt is not None:
														raise ValueError('''You have to specify exactly one type of prompt. Either text or visual prompt.'''  )

										if text is not None:
														_SCREAMING_SNAKE_CASE			  =self.tokenizer(_a				,    return_tensors=_a				,    **_a  )

										if visual_prompt is not None:
														_SCREAMING_SNAKE_CASE			  =self.image_processor(_a				,    return_tensors=_a				,    **_a  )

										if images is not None:
														_SCREAMING_SNAKE_CASE			  =self.image_processor(_a				,    return_tensors=_a				,    **_a  )

										if visual_prompt is not None and images is not None:
														_SCREAMING_SNAKE_CASE			  ={
														    '''pixel_values''': image_features.pixel_values,
														    '''conditional_pixel_values''': prompt_features.pixel_values,
														}
														return encoding
										elif text is not None and images is not None:
														_SCREAMING_SNAKE_CASE			  =image_features.pixel_values
														return encoding
										elif text is not None:
														return encoding
										elif visual_prompt is not None:
														_SCREAMING_SNAKE_CASE			  ={
														    '''conditional_pixel_values''': prompt_features.pixel_values,
														}
														return encoding
										else:
														return BatchEncoding(data=dict(**_a  )				,    tensor_type=_a  )




						def 							__UpperCamelCase				(       self					:      Any				,    *_a					:      str				,    **_a					:      List[Any]  )							->     Tuple:


										"""simple docstring"""





										return self.tokenizer.batch_decode(*_a				,    **_a  )




						def 							__UpperCamelCase				(       self					:      Dict				,    *_a					:      str				,    **_a					:      List[Any]  )							->     List[Any]:


										"""simple docstring"""





										return self.tokenizer.decode(*_a				,    **_a  )




						@property
						def 							__UpperCamelCase				(       self					:      Optional[int]  )							->     int:


										"""simple docstring"""





										warnings.warn(
										    '''`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'''				,    _a				,    )
										return self.image_processor_class




						@property
						def 							__UpperCamelCase				(       self					:      Optional[Any]  )							->     Union[str, Any]:


										"""simple docstring"""





										warnings.warn(
										    '''`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'''				,    _a				,    )
										return self.image_processor