






"""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 					_UpperCAmelCase       :




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




					def   A  (				self     :						Any   )  ->  Optional[Any]:
							lowercase_ : Tuple							       =   ids_tensor([self.batch_size, self.seq_length]    ,						self.vocab_size   )

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

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

							lowercase_ : List[Any]							       =   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     :						int   )  ->  List[Any]:
							(
							    (
							    lowercase_
							)       ,					(
							    lowercase_
							)       ,					(
							    lowercase_
							)       ,					(
							    lowercase_
							)       ,					(
							    lowercase_
							)       ,					(
							    lowercase_
							)       ,					
							) : Dict							       =   self.prepare_config_and_inputs()

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

							lowercase_ : Any							       =   [input_ids, input_mask]
							lowercase_ : Any							       =   model(A   )

							lowercase_ : Optional[int]							       =   model(A   )

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




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

							lowercase_ : Dict							       =   TFEsmModel(config=A   )
							lowercase_ : Dict							       =   {
							    '''input_ids''': input_ids,
							    '''attention_mask''': input_mask,
							    '''encoder_hidden_states''': encoder_hidden_states,
							    '''encoder_attention_mask''': encoder_attention_mask,
							}
							lowercase_ : str							       =   model(A   )

							lowercase_ : Union[str, Any]							       =   [input_ids, input_mask]
							lowercase_ : str							       =   model(A    ,						encoder_hidden_states=A   )

							# Also check the case where encoder outputs are not passed
							lowercase_ : Dict							       =   model(A    ,						attention_mask=A   )

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




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




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






					def   A  (				self     :						Optional[Any]   )  ->  List[str]:
							lowercase_ : Dict							       =   self.prepare_config_and_inputs()
							(
							    (
							    lowercase_
							)       ,					(
							    lowercase_
							)       ,					(
							    lowercase_
							)       ,					(
							    lowercase_
							)       ,					(
							    lowercase_
							)       ,					(
							    lowercase_
							)       ,					
							) : str							       =   config_and_inputs
							lowercase_ : Optional[int]							       =   {'''input_ids''': input_ids, '''attention_mask''': input_mask}
							return config, inputs_dict





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




					def   A  (				self     :						int   )  ->  Tuple:
							lowercase_ : Any							       =   TFEsmModelTester(self   )
							lowercase_ : Optional[Any]							       =   ConfigTester(self    ,						config_class=A    ,						hidden_size=37   )




					def   A  (				self     :						Optional[Any]   )  ->  Dict:
							self.config_tester.run_common_tests()




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




					def   A  (				self     :						Tuple   )  ->  Any:
							lowercase_ : Dict							       =   self.model_tester.prepare_config_and_inputs_for_decoder()
							self.model_tester.create_and_check_model_as_decoder(*A   )




					def   A  (				self     :						Dict   )  ->  Optional[Any]:
							lowercase_ : Dict							       =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_lm(*A   )




					def   A  (				self     :						List[str]   )  ->  List[str]:
							lowercase_ : Union[str, Any]							       =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_token_classification(*A   )




					@slow
					def   A  (				self     :						str   )  ->  Optional[Any]:
							for model_name in TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									lowercase_ : str							       =   TFEsmModel.from_pretrained(A   )
									self.assertIsNotNone(A   )




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




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






					def   A  (				self     :						str   )  ->  Optional[Any]:
							lowercase_       ,					lowercase_ : List[Any]							       =   self.model_tester.prepare_config_and_inputs_for_common()

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





@require_tf
class 					_UpperCAmelCase       ( unittest.TestCase							):




					@slow
					def   A  (				self     :						Optional[Any]   )  ->  List[str]:
							lowercase_ : int							       =   TFEsmForMaskedLM.from_pretrained('''facebook/esm2_t6_8M_UR50D'''   )

							lowercase_ : Optional[int]							       =   tf.constant([[0, 1, 2, 3, 4, 5]]   )
							lowercase_ : Union[str, Any]							       =   model(A   )[0]
							lowercase_ : int							       =   [1, 6, 33]
							self.assertEqual(list(output.numpy().shape   )    ,						A   )
							# compare the actual values for a slice.
							lowercase_ : str							       =   tf.constant(
							    [
							        [
							            [8.921518, -10.589814, -6.4671307],
							            [-6.3967156, -13.911377, -1.1211915],
							            [-7.781247, -13.951557, -3.740592],
							        ]
							    ]   )
							self.assertTrue(numpy.allclose(output[:, :3, :3].numpy()    ,						expected_slice.numpy()    ,						atol=1e-2   )   )






					@slow
					def   A  (				self     :						Dict   )  ->  List[str]:
							lowercase_ : Optional[int]							       =   TFEsmModel.from_pretrained('''facebook/esm2_t6_8M_UR50D'''   )

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











"""simple docstring"""





from typing import Any






class      a						:






    def __init__(       self     :							Tuple       ,						__SCREAMING_SNAKE_CASE     :							Any					)     ->		List[Any]:
      lowerCamelCase_         =						data
      lowerCamelCase_         =						None






class      a						:






    def __init__(       self     :							Union[str, Any]					)     ->		List[Any]:
      lowerCamelCase_         =						None






    def    UpperCamelCase       (       self     :							Dict					)     ->		Optional[int]:
      lowerCamelCase_         =						self.head
      while temp is not None:
        print(temp.data       ,						end=' '					)
        lowerCamelCase_         =						temp.next
      print()






    def    UpperCamelCase       (       self     :							List[Any]       ,						__SCREAMING_SNAKE_CASE     :							Any					)     ->		Union[str, Any]:
      lowerCamelCase_         =						Node(__SCREAMING_SNAKE_CASE					)
      lowerCamelCase_         =						self.head
      lowerCamelCase_         =						new_node






    def    UpperCamelCase       (       self     :							Dict       ,						__SCREAMING_SNAKE_CASE     :							List[str]       ,						__SCREAMING_SNAKE_CASE     :							int					)     ->		Union[str, Any]:
      if node_data_a == node_data_a:
        return
      else:
        lowerCamelCase_         =						self.head
        while node_a is not None and node_a.data != node_data_a:
          lowerCamelCase_         =						node_a.next

        lowerCamelCase_         =						self.head
        while node_a is not None and node_a.data != node_data_a:
          lowerCamelCase_         =						node_a.next

        if node_a is None or node_a is None:
          return

        lowerCamelCase_     ,	lowerCamelCase_         =						node_a.data, node_a.data


if __name__ == "__main__":
  _SCREAMING_SNAKE_CASE					:				Optional[int]					    =						LinkedList()
  for i in range(5, 0, -1):
    ll.push(i)

  ll.print_list()

  ll.swap_nodes(1, 4)
  print('''After swapping''')
  ll.print_list()




