


from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import ResNetConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
							import tensorflow as tf

							from transformers import TFResNetForImageClassification, TFResNetModel
							from transformers.models.resnet.modeling_tf_resnet import TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
							from PIL import Image

							from transformers import AutoImageProcessor





class        UpperCamelCase__   :

					def __init__(     self       :   Optional[int]							,					UpperCamelCase__       :   Optional[Any]							,					UpperCamelCase__       :   Tuple=3							,					UpperCamelCase__       :   Optional[int]=32							,					UpperCamelCase__       :   Any=3							,					UpperCamelCase__       :   List[str]=10							,					UpperCamelCase__       :   Dict=[10, 20, 30, 40]							,					UpperCamelCase__       :   Any=[1, 1, 2, 1]							,					UpperCamelCase__       :   Any=True							,					UpperCamelCase__       :   Union[str, Any]=True							,					UpperCamelCase__       :   Any="relu"							,					UpperCamelCase__       :   Union[str, Any]=3							,					UpperCamelCase__       :   List[str]=None							,					):






										'''simple docstring'''






										lowercase_  							=			parent
										lowercase_  							=			batch_size
										lowercase_  							=			image_size
										lowercase_  							=			num_channels
										lowercase_  							=			embeddings_size
										lowercase_  							=			hidden_sizes
										lowercase_  							=			depths
										lowercase_  							=			is_training
										lowercase_  							=			use_labels
										lowercase_  							=			hidden_act
										lowercase_  							=			num_labels
										lowercase_  							=			scope
										lowercase_  							=			len(_A       )

					def   UpperCAmelCase__       (     self       :   int       ):






										'''simple docstring'''






										lowercase_  							=			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

										lowercase_  							=			None
										if self.use_labels:
															lowercase_  							=			ids_tensor([self.batch_size]							,					self.num_labels       )

										lowercase_  							=			self.get_config()

										return config, pixel_values, labels

					def   UpperCAmelCase__       (     self       :   Dict       ):






										'''simple docstring'''






										return ResNetConfig(
										    num_channels=self.num_channels							,					embeddings_size=self.embeddings_size							,					hidden_sizes=self.hidden_sizes							,					depths=self.depths							,					hidden_act=self.hidden_act							,					num_labels=self.num_labels							,					image_size=self.image_size							,					)

					def   UpperCAmelCase__       (     self       :   List[Any]							,					UpperCamelCase__       :   Any							,					UpperCamelCase__       :   Optional[int]							,					UpperCamelCase__       :   int       ):






										'''simple docstring'''






										lowercase_  							=			TFResNetModel(config=_A       )
										lowercase_  							=			model(_A       )
										# expected last hidden states: B, C, H // 32, W // 32
										self.parent.assertEqual(
										    result.last_hidden_state.shape							,					(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)							,					)

					def   UpperCAmelCase__       (     self       :   Dict							,					UpperCamelCase__       :   List[Any]							,					UpperCamelCase__       :   Any							,					UpperCamelCase__       :   Dict       ):






										'''simple docstring'''






										lowercase_  							=			self.num_labels
										lowercase_  							=			TFResNetForImageClassification(_A       )
										lowercase_  							=			model(_A							,					labels=_A       )
										self.parent.assertEqual(result.logits.shape							,					(self.batch_size, self.num_labels)       )







					def   UpperCAmelCase__       (     self       :   Dict       ):






										'''simple docstring'''






										lowercase_  							=			self.prepare_config_and_inputs()
										lowercase_  							=			config_and_inputs
										lowercase_  							=			{'pixel_values': pixel_values}
										return config, inputs_dict





@require_tf
class        UpperCamelCase__   (	a__							,				a__							,				unittest.TestCase   ):
					__SCREAMING_SNAKE_CASE       :  Dict						=   (TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
					__SCREAMING_SNAKE_CASE       :  Tuple						=   (
					    {'feature-extraction': TFResNetModel, 'image-classification': TFResNetForImageClassification}
					    if is_tf_available()
					    else {}
					)

					__SCREAMING_SNAKE_CASE       :  Dict						=   False
					__SCREAMING_SNAKE_CASE       :  List[Any]						=   False
					__SCREAMING_SNAKE_CASE       :  Optional[int]						=   False
					__SCREAMING_SNAKE_CASE       :  Tuple						=   False
					__SCREAMING_SNAKE_CASE       :  Union[str, Any]						=   False

					def   UpperCAmelCase__       (     self       :   str       ):






										'''simple docstring'''






										lowercase_  							=			TFResNetModelTester(self       )
										lowercase_  							=			ConfigTester(self							,					config_class=_A							,					has_text_modality=_A       )

					def   UpperCAmelCase__       (     self       :   Tuple       ):






										'''simple docstring'''






										self.create_and_test_config_common_properties()
										self.config_tester.create_and_test_config_to_json_string()
										self.config_tester.create_and_test_config_to_json_file()
										self.config_tester.create_and_test_config_from_and_save_pretrained()
										self.config_tester.create_and_test_config_with_num_labels()
										self.config_tester.check_config_can_be_init_without_params()
										self.config_tester.check_config_arguments_init()

					def   UpperCAmelCase__       (     self       :   Optional[int]       ):






										'''simple docstring'''






										return

					@unittest.skip(reason="""ResNet does not use inputs_embeds"""       )
					def   UpperCAmelCase__       (     self       :   int       ):






										'''simple docstring'''






										pass

					@unittest.skip(reason="""ResNet does not support input and output embeddings"""       )
					def   UpperCAmelCase__       (     self       :   List[str]       ):






										'''simple docstring'''






										pass

					def   UpperCAmelCase__       (     self       :   List[str]       ):






										'''simple docstring'''






										lowercase_  							=			self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
															lowercase_  							=			model_class(_A       )
															lowercase_  							=			inspect.signature(model.call       )
															# signature.parameters is an OrderedDict => so arg_names order is deterministic
															lowercase_  							=			[*signature.parameters.keys()]

															lowercase_  							=			['pixel_values']
															self.assertListEqual(arg_names[:1]							,					_A       )

					def   UpperCAmelCase__       (     self       :   Tuple       ):






										'''simple docstring'''






										lowercase_  							=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*_A       )

					def   UpperCAmelCase__       (     self       :   Optional[int]       ):






										'''simple docstring'''






										def check_hidden_states_output(UpperCamelCase__       :   int							,					UpperCamelCase__       :   Tuple							,					UpperCamelCase__       :   Any       ):
															lowercase_  							=			model_class(_A       )
															lowercase_  							=			model(**self._prepare_for_class(_A							,					_A       )       )

															lowercase_  							=			outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

															lowercase_  							=			self.model_tester.num_stages
															self.assertEqual(len(_A       )							,					expected_num_stages + 1       )

															# ResNet's feature maps are of shape (batch_size, num_channels, height, width)
															self.assertListEqual(
															    list(hidden_states[0].shape[-2:]       )							,					[self.model_tester.image_size // 4, self.model_tester.image_size // 4]							,					)

										lowercase_  							=			self.model_tester.prepare_config_and_inputs_for_common()
										lowercase_  							=			['basic', 'bottleneck']
										for model_class in self.all_model_classes:
															for layer_type in layers_type:
																				lowercase_  							=			layer_type
																				lowercase_  							=			True
																				check_hidden_states_output(_A							,					_A							,					_A       )

																				# check that output_hidden_states also work using config
																				del inputs_dict["output_hidden_states"]
																				lowercase_  							=			True

																				check_hidden_states_output(_A							,					_A							,					_A       )

					def   UpperCAmelCase__       (     self       :   List[str]       ):






										'''simple docstring'''






										lowercase_  							=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*_A       )







					@slow
					def   UpperCAmelCase__       (     self       :   Optional[int]       ):






										'''simple docstring'''






										for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															lowercase_  							=			TFResNetModel.from_pretrained(_A       )
															self.assertIsNotNone(_A       )



def 			UpperCAmelCase_				(      ):
					lowercase_  							=			Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""  )
					return image





@require_tf
@require_vision
class        UpperCamelCase__   (	unittest.TestCase   ):

					@cached_property
					def   UpperCAmelCase__       (     self       :   Optional[int]       ):






										'''simple docstring'''






										return (
										    AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]       )
										    if is_vision_available()
										    else None
										)







					@slow
					def   UpperCAmelCase__       (     self       :   Union[str, Any]       ):






										'''simple docstring'''






										lowercase_  							=			TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]       )

										lowercase_  							=			self.default_image_processor
										lowercase_  							=			prepare_img()
										lowercase_  							=			image_processor(images=_A							,					return_tensors="""tf"""       )

										# forward pass
										lowercase_  							=			model(**_A       )

										# verify the logits
										lowercase_  							=			tf.TensorShape((1, 1_000)       )
										self.assertEqual(outputs.logits.shape							,					_A       )

										lowercase_  							=			tf.constant([-11.1_069, -9.7_877, -8.3_777]       )

										self.assertTrue(np.allclose(outputs.logits[0, :3].numpy()							,					_A							,					atol=1e-4       )       )






from dataclasses import asdict, dataclass
from typing import Optional

from ...configuration_utils import PretrainedConfig
from ...utils import logging


a					  =     logging.get_logger(__name__)

# TODO Update this
a					  =     {
    'facebook/esm-1b': 'https://huggingface.co/facebook/esm-1b/resolve/main/config.json',
    # See all ESM models at https://huggingface.co/models?filter=esm
}







class        UpperCamelCase__   (	__magic_name__   ):
					__SCREAMING_SNAKE_CASE       :  Tuple						=   'esm'

					def __init__(     self       :   Optional[Any]							,					UpperCamelCase__       :   Dict=None							,					UpperCamelCase__       :   Tuple=None							,					UpperCamelCase__       :   List[Any]=None							,					UpperCamelCase__       :   List[Any]=768							,					UpperCamelCase__       :   Tuple=12							,					UpperCamelCase__       :   Optional[int]=12							,					UpperCamelCase__       :   Dict=3_072							,					UpperCamelCase__       :   Union[str, Any]=0.1							,					UpperCamelCase__       :   Dict=0.1							,					UpperCamelCase__       :   Optional[int]=1_026							,					UpperCamelCase__       :   Any=0.02							,					UpperCamelCase__       :   Dict=1e-12							,					UpperCamelCase__       :   List[str]="absolute"							,					UpperCamelCase__       :   Union[str, Any]=True							,					UpperCamelCase__       :   Tuple=None							,					UpperCamelCase__       :   Union[str, Any]=False							,					UpperCamelCase__       :   Optional[int]=False							,					UpperCamelCase__       :   Dict=None							,					UpperCamelCase__       :   str=None							,					**UpperCamelCase__       :   str							,					):






										'''simple docstring'''






										super().__init__(pad_token_id=UpperCamelCase__							,					mask_token_id=UpperCamelCase__							,					**UpperCamelCase__       )

										lowercase_  							=			vocab_size
										lowercase_  							=			hidden_size
										lowercase_  							=			num_hidden_layers
										lowercase_  							=			num_attention_heads
										lowercase_  							=			intermediate_size
										lowercase_  							=			hidden_dropout_prob
										lowercase_  							=			attention_probs_dropout_prob
										lowercase_  							=			max_position_embeddings
										lowercase_  							=			initializer_range
										lowercase_  							=			layer_norm_eps
										lowercase_  							=			position_embedding_type
										lowercase_  							=			use_cache
										lowercase_  							=			emb_layer_norm_before
										lowercase_  							=			token_dropout
										lowercase_  							=			is_folding_model
										if is_folding_model:
															if esmfold_config is None:
																				logger.info("""No esmfold_config supplied for folding model, using default values."""       )
																				lowercase_  							=			EsmFoldConfig()
															elif isinstance(UpperCamelCase__							,					UpperCamelCase__       ):
																				lowercase_  							=			EsmFoldConfig(**UpperCamelCase__       )
															lowercase_  							=			esmfold_config
															if vocab_list is None:
																				logger.warning("""No vocab_list supplied for folding model, assuming the ESM-2 vocabulary!"""       )
																				lowercase_  							=			get_default_vocab_list()
															else:
																				lowercase_  							=			vocab_list
										else:
															lowercase_  							=			None
															lowercase_  							=			None
										if self.esmfold_config is not None and getattr(self.esmfold_config							,					"""use_esm_attn_map"""							,					UpperCamelCase__       ):
															raise ValueError("""The HuggingFace port of ESMFold does not support use_esm_attn_map at this time!"""       )







					def   UpperCAmelCase__       (     self       :   List[Any]       ):






										'''simple docstring'''






										lowercase_  							=			super().to_dict()
										if isinstance(self.esmfold_config							,					UpperCamelCase__       ):
															lowercase_  							=			self.esmfold_config.to_dict()
										return output







@dataclass
class        UpperCamelCase__   :
					__SCREAMING_SNAKE_CASE       :  str						=   None
					__SCREAMING_SNAKE_CASE       :  bool						=   True
					__SCREAMING_SNAKE_CASE       :  bool						=   False
					__SCREAMING_SNAKE_CASE       :  bool						=   False
					__SCREAMING_SNAKE_CASE       :  bool						=   False
					__SCREAMING_SNAKE_CASE       :  float						=   0

					__SCREAMING_SNAKE_CASE       :  bool						=   True
					__SCREAMING_SNAKE_CASE       :  bool						=   False

					__SCREAMING_SNAKE_CASE       :  int						=   128
					__SCREAMING_SNAKE_CASE       :  "TrunkConfig"						=   None

					def   UpperCAmelCase__       (     self       :   Tuple       ):






										'''simple docstring'''






										if self.trunk is None:
															lowercase_  							=			TrunkConfig()
										elif isinstance(self.trunk							,					UpperCamelCase__       ):
															lowercase_  							=			TrunkConfig(**self.trunk       )







					def   UpperCAmelCase__       (     self       :   Union[str, Any]       ):






										'''simple docstring'''






										lowercase_  							=			asdict(self       )
										lowercase_  							=			self.trunk.to_dict()
										return output







@dataclass
class        UpperCamelCase__   :
					__SCREAMING_SNAKE_CASE       :  int						=   48
					__SCREAMING_SNAKE_CASE       :  int						=   1024
					__SCREAMING_SNAKE_CASE       :  int						=   128
					__SCREAMING_SNAKE_CASE       :  int						=   32
					__SCREAMING_SNAKE_CASE       :  int						=   32
					__SCREAMING_SNAKE_CASE       :  int						=   32
					__SCREAMING_SNAKE_CASE       :  float						=   0
					__SCREAMING_SNAKE_CASE       :  float						=   0
					__SCREAMING_SNAKE_CASE       :  bool						=   False
					__SCREAMING_SNAKE_CASE       :  int						=   4
					__SCREAMING_SNAKE_CASE       :  Optional[int]						=   128
					__SCREAMING_SNAKE_CASE       :  "StructureModuleConfig"						=   None

					def   UpperCAmelCase__       (     self       :   Union[str, Any]       ):






										'''simple docstring'''






										if self.structure_module is None:
															lowercase_  							=			StructureModuleConfig()
										elif isinstance(self.structure_module							,					UpperCamelCase__       ):
															lowercase_  							=			StructureModuleConfig(**self.structure_module       )

										if self.max_recycles <= 0:
															raise ValueError(F'''`max_recycles` should be positive, got {self.max_recycles}.'''       )
										if self.sequence_state_dim % self.sequence_state_dim != 0:
															raise ValueError(
															    """`sequence_state_dim` should be a round multiple of `sequence_state_dim`, got"""
															    F''' {self.sequence_state_dim} and {self.sequence_state_dim}.'''       )
										if self.pairwise_state_dim % self.pairwise_state_dim != 0:
															raise ValueError(
															    """`pairwise_state_dim` should be a round multiple of `pairwise_state_dim`, got"""
															    F''' {self.pairwise_state_dim} and {self.pairwise_state_dim}.'''       )

										lowercase_  							=			self.sequence_state_dim // self.sequence_head_width
										lowercase_  							=			self.pairwise_state_dim // self.pairwise_head_width

										if self.sequence_state_dim != sequence_num_heads * self.sequence_head_width:
															raise ValueError(
															    """`sequence_state_dim` should be equal to `sequence_num_heads * sequence_head_width, got"""
															    F''' {self.sequence_state_dim} != {sequence_num_heads} * {self.sequence_head_width}.'''       )
										if self.pairwise_state_dim != pairwise_num_heads * self.pairwise_head_width:
															raise ValueError(
															    """`pairwise_state_dim` should be equal to `pairwise_num_heads * pairwise_head_width, got"""
															    F''' {self.pairwise_state_dim} != {pairwise_num_heads} * {self.pairwise_head_width}.'''       )
										if self.pairwise_state_dim % 2 != 0:
															raise ValueError(F'''`pairwise_state_dim` should be even, got {self.pairwise_state_dim}.'''       )

										if self.dropout >= 0.4:
															raise ValueError(F'''`dropout` should not be greater than 0.4, got {self.dropout}.'''       )







					def   UpperCAmelCase__       (     self       :   Any       ):






										'''simple docstring'''






										lowercase_  							=			asdict(self       )
										lowercase_  							=			self.structure_module.to_dict()
										return output







@dataclass
class        UpperCamelCase__   :
					__SCREAMING_SNAKE_CASE       :  int						=   384
					__SCREAMING_SNAKE_CASE       :  int						=   128
					__SCREAMING_SNAKE_CASE       :  int						=   16
					__SCREAMING_SNAKE_CASE       :  int						=   128
					__SCREAMING_SNAKE_CASE       :  int						=   12
					__SCREAMING_SNAKE_CASE       :  int						=   4
					__SCREAMING_SNAKE_CASE       :  int						=   8
					__SCREAMING_SNAKE_CASE       :  float						=   0.1
					__SCREAMING_SNAKE_CASE       :  int						=   8
					__SCREAMING_SNAKE_CASE       :  int						=   1
					__SCREAMING_SNAKE_CASE       :  int						=   2
					__SCREAMING_SNAKE_CASE       :  int						=   7
					__SCREAMING_SNAKE_CASE       :  int						=   10
					__SCREAMING_SNAKE_CASE       :  float						=   1e-8
					__SCREAMING_SNAKE_CASE       :  float						=   1e5

					def   UpperCAmelCase__       (     self       :   List[str]       ):






										'''simple docstring'''






										return asdict(self       )



def 			UpperCAmelCase_				(      ):
					return (
					    "<cls>",
					    "<pad>",
					    "<eos>",
					    "<unk>",
					    "L",
					    "A",
					    "G",
					    "V",
					    "S",
					    "E",
					    "R",
					    "T",
					    "I",
					    "D",
					    "P",
					    "K",
					    "Q",
					    "N",
					    "F",
					    "Y",
					    "M",
					    "H",
					    "W",
					    "C",
					    "X",
					    "B",
					    "U",
					    "Z",
					    "O",
					    ".",
					    "-",
					    "<null_1>",
					    "<mask>",
					)


