

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




	def __init__(     self						:     Optional[Any]					,      __A						:     List[Any]					,      ):
		__A :			List[Any]		    =			parent
		__A :			Tuple		    =			13
		__A :			Any		    =			7
		__A :			Any		    =			True
		__A :			Any		    =			True
		__A :			Dict		    =			True
		__A :			int		    =			99
		__A :			List[str]		    =			32
		__A :			Optional[Any]		    =			2
		__A :			Dict		    =			4
		__A :			Dict		    =			37
		__A :			List[str]		    =			"""gelu"""
		__A :			str		    =			0.1
		__A :			List[Any]		    =			0.1
		__A :			Dict		    =			512
		__A :			str		    =			16
		__A :			Union[str, Any]		    =			2
		__A :			Optional[int]		    =			0.0_2
		__A :			Optional[int]		    =			3
		__A :			int		    =			4
		__A :			Optional[int]		    =			None




	def        lowerCAmelCase_       (     self						:     Optional[int]							):
		__A :			str		    =			ids_tensor([self.batch_size, self.seq_length]					,      self.vocab_size							)

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

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

		__A :			str		    =			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						:     str							):
		(
		    (
		    __A
		)    ,				(
		    __A
		)    ,				(
		    __A
		)    ,				(
		    __A
		)    ,				(
		    __A
		)    ,				(
		    __A
		)    ,				
		) :			int		    =			self.prepare_config_and_inputs()

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

		__A :			List[str]		    =			[input_ids, input_mask]
		__A :			List[str]		    =			model(__A							)

		__A :			Tuple		    =			model(__A							)

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




	def        lowerCAmelCase_       (     self						:     int					,      __A						:     str					,      __A						:     Any					,      __A						:     Optional[Any]					,      __A						:     str					,      __A						:     int					,      __A						:     int					,      __A						:     List[str]					,      __A						:     str					,      ):
		__A :			List[str]		    =			True

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

		__A :			List[Any]		    =			[input_ids, input_mask]
		__A :			int		    =			model(__A					,      encoder_hidden_states=__A							)

		# Also check the case where encoder outputs are not passed
		__A :			Tuple		    =			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						:     Dict					,      __A						:     Union[str, Any]					,      __A						:     Dict					,      __A						:     List[str]					,      __A						:     Tuple					,      __A						:     int					,      __A						:     Tuple							):
		__A :			Optional[Any]		    =			TFEsmForMaskedLM(config=__A							)
		__A :			Optional[int]		    =			model([input_ids, input_mask]							)
		self.parent.assertEqual(result.logits.shape					,      (self.batch_size, self.seq_length, self.vocab_size)							)




	def        lowerCAmelCase_       (     self						:     Optional[int]					,      __A						:     Dict					,      __A						:     Any					,      __A						:     Any					,      __A						:     str					,      __A						:     Dict					,      __A						:     Any							):
		__A :			Tuple		    =			self.num_labels
		__A :			Any		    =			TFEsmForTokenClassification(config=__A							)
		__A :			Tuple		    =			{"""input_ids""": input_ids, """attention_mask""": input_mask}
		__A :			List[Any]		    =			model(__A							)
		self.parent.assertEqual(result.logits.shape					,      (self.batch_size, self.seq_length, self.num_labels)							)




	def        lowerCAmelCase_       (     self						:     List[Any]							):
		__A :			Tuple		    =			self.prepare_config_and_inputs()
		(
		    (
		    __A
		)    ,				(
		    __A
		)    ,				(
		    __A
		)    ,				(
		    __A
		)    ,				(
		    __A
		)    ,				(
		    __A
		)    ,				
		) :			str		    =			config_and_inputs
		__A :			List[str]		    =			{"""input_ids""": input_ids, """attention_mask""": input_mask}
		return config, inputs_dict






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




	def        lowerCAmelCase_       (     self						:     int							):
		__A :			Union[str, Any]		    =			TFEsmModelTester(self							)
		__A :			List[Any]		    =			ConfigTester(self					,      config_class=__A					,      hidden_size=37							)




	def        lowerCAmelCase_       (     self						:     Dict							):
		self.config_tester.run_common_tests()




	def        lowerCAmelCase_       (     self						:     int							):
		__A :			Optional[int]		    =			self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_model(*__A							)




	def        lowerCAmelCase_       (     self						:     Dict							):
		__A :			List[Any]		    =			self.model_tester.prepare_config_and_inputs_for_decoder()
		self.model_tester.create_and_check_model_as_decoder(*__A							)




	def        lowerCAmelCase_       (     self						:     Tuple							):
		__A :			int		    =			self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_for_masked_lm(*__A							)




	def        lowerCAmelCase_       (     self						:     Optional[int]							):
		__A :			List[Any]		    =			self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_for_token_classification(*__A							)




	@slow
	def        lowerCAmelCase_       (     self						:     Dict							):
		for model_name in TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
			__A :			Tuple		    =			TFEsmModel.from_pretrained(__A							)
			self.assertIsNotNone(__A							)




	@unittest.skip("""Protein models do not support embedding resizing."""							)
	def        lowerCAmelCase_       (     self						:     int							):
		pass




	@unittest.skip("""Protein models do not support embedding resizing."""							)
	def        lowerCAmelCase_       (     self						:     str							):
		pass




	def        lowerCAmelCase_       (     self						:     Optional[Any]							):
		__A    ,				__A :			List[Any]		    =			self.model_tester.prepare_config_and_inputs_for_common()

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






@require_tf
class      lowerCamelCase_      (	unittest.TestCase	):




	@slow
	def        lowerCAmelCase_       (     self						:     Any							):
		__A :			Optional[int]		    =			TFEsmForMaskedLM.from_pretrained("""facebook/esm2_t6_8M_UR50D"""							)

		__A :			Union[str, Any]		    =			tf.constant([[0, 1, 2, 3, 4, 5]]							)
		__A :			Optional[int]		    =			model(__A							)[0]
		__A :			Dict		    =			[1, 6, 33]
		self.assertEqual(list(output.numpy().shape							)					,      __A							)
		# compare the actual values for a slice.
		__A :			Union[str, Any]		    =			tf.constant(
		    [
		        [
		            [8.9_2_1_5_1_8, -1_0.5_8_9_8_1_4, -6.4_6_7_1_3_0_7],
		            [-6.3_9_6_7_1_5_6, -1_3.9_1_1_3_7_7, -1.1_2_1_1_9_1_5],
		            [-7.7_8_1_2_4_7, -1_3.9_5_1_5_5_7, -3.7_4_0_5_9_2],
		        ]
		    ]							)
		self.assertTrue(numpy.allclose(output[:, :3, :3].numpy()					,      expected_slice.numpy()					,      atol=1e-2							)							)




	@slow
	def        lowerCAmelCase_       (     self						:     Optional[int]							):
		__A :			str		    =			TFEsmModel.from_pretrained("""facebook/esm2_t6_8M_UR50D"""							)

		__A :			Optional[Any]		    =			tf.constant([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]]							)
		__A :			Tuple		    =			model(__A							)[0]
		# compare the actual values for a slice.
		__A :			Union[str, Any]		    =			tf.constant(
		    [
		        [
		            [0.1_4_4_4_3_0_9_2, 0.5_4_1_2_5_3_2_7, 0.3_2_4_7_7_3_9],
		            [0.3_0_3_4_0_4_8_4, 0.0_0_5_2_6_6_7_6, 0.3_1_0_7_7_7_2_2],
		            [0.3_2_2_7_8_0_4_3, -0.2_4_9_8_7_0_9_6, 0.3_4_1_4_6_2_8],
		        ]
		    ]							)
		self.assertTrue(numpy.allclose(output[:, :3, :3].numpy()					,      expected_slice.numpy()					,      atol=1e-4							)							)









class 	__lowercase					:





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






         """simple docstring"""







         UpperCAmelCase      					=  {}





      def 							_lowercase					(		self    :       str							)     -> None:






         """simple docstring"""







         print(self.vertex							)
         for i in self.vertex:
            print(__lowerCamelCase       ,							""" -> """       ,							""" -> """.join([str(__lowerCamelCase							) for j in self.vertex[i]]							)							)





      def 							_lowercase					(		self    :       Optional[Any]       ,							__lowerCamelCase    :       int       ,							__lowerCamelCase    :       int							)     -> None:






         """simple docstring"""







         if from_vertex in self.vertex:
            self.vertex[from_vertex].append(__lowerCamelCase							)
         else:
            # else make a new vertex
            UpperCAmelCase      					=  [to_vertex]





      def 							_lowercase					(		self    :       str							)     -> None:






         """simple docstring"""







         UpperCAmelCase      					=  [False] * len(self.vertex							)

         # call the recursive helper function
         for i in range(len(self.vertex							)							):
            if not visited[i]:
               self.dfs_recursive(__lowerCamelCase       ,							__lowerCamelCase							)





      def 							_lowercase					(		self    :       Optional[int]       ,							__lowerCamelCase    :       int       ,							__lowerCamelCase    :       list							)     -> None:






         """simple docstring"""







         UpperCAmelCase      					=  True

         print(__lowerCamelCase       ,							end=""" """							)

         # Recur for all the vertices that are adjacent to this node
         for i in self.vertex:
            if not visited[i]:
               self.dfs_recursive(__lowerCamelCase       ,							__lowerCamelCase							)


if __name__ == "__main__":
 __a	 =      Graph()
 g.add_edge(0, 1)
 g.add_edge(0, 2)
 g.add_edge(1, 2)
 g.add_edge(2, 0)
 g.add_edge(2, 3)
 g.add_edge(3, 3)

 g.print_graph()
 print("""DFS:""")
 g.dfs()

 # OUTPUT:
 # 0  ->  1 -> 2
 # 1  ->  2
 # 2  ->  0 -> 3
 # 3  ->  3
 # DFS:
 #  0 1 2 3



