






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			:



    """simple docstring"""



    def __init__(      self    :    Optional[int]			,		UpperCamelCase__    :    str			,		):






           '''simple docstring'''







           snake_case__	  =       parent
           snake_case__	  =       1_3
           snake_case__	  =       7
           snake_case__	  =       True
           snake_case__	  =       True
           snake_case__	  =       True
           snake_case__	  =       9_9
           snake_case__	  =       3_2
           snake_case__	  =       2
           snake_case__	  =       4
           snake_case__	  =       3_7
           snake_case__	  =       """gelu"""
           snake_case__	  =       0.1
           snake_case__	  =       0.1
           snake_case__	  =       5_1_2
           snake_case__	  =       1_6
           snake_case__	  =       2
           snake_case__	  =       0.02
           snake_case__	  =       3
           snake_case__	  =       4
           snake_case__	  =       None



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






           '''simple docstring'''







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

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

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

           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 					__magic_name__							(      self    :    int):






           '''simple docstring'''







           (
               (
               snake_case__ 
           )  , (
               snake_case__ 
           )  , (
               snake_case__ 
           )  , (
               snake_case__ 
           )  , (
               snake_case__ 
           )  , (
               snake_case__ 
           )  ,  
           )	  =       self.prepare_config_and_inputs()

           snake_case__	  =       True
           snake_case__	  =       floats_tensor([self.batch_size, self.seq_length, self.hidden_size])
           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 					__magic_name__							(      self    :    List[Any]			,		UpperCamelCase__    :    str			,		UpperCamelCase__    :    str			,		UpperCamelCase__    :    Optional[int]			,		UpperCamelCase__    :    Any			,		UpperCamelCase__    :    List[str]			,		UpperCamelCase__    :    List[str]):






           '''simple docstring'''







           snake_case__	  =       TFEsmModel(config=UpperCamelCase__)
           snake_case__	  =       {"""input_ids""": input_ids, """attention_mask""": input_mask}
           snake_case__	  =       model(UpperCamelCase__)

           snake_case__	  =       [input_ids, input_mask]
           snake_case__	  =       model(UpperCamelCase__)

           snake_case__	  =       model(UpperCamelCase__)

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



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






           '''simple docstring'''







           snake_case__	  =       True

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

           snake_case__	  =       [input_ids, input_mask]
           snake_case__	  =       model(UpperCamelCase__			,		encoder_hidden_states=UpperCamelCase__)

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

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



    def 					__magic_name__							(      self    :    Optional[Any]			,		UpperCamelCase__    :    Any			,		UpperCamelCase__    :    Any			,		UpperCamelCase__    :    int			,		UpperCamelCase__    :    str			,		UpperCamelCase__    :    Tuple			,		UpperCamelCase__    :    Optional[int]):






           '''simple docstring'''







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



    def 					__magic_name__							(      self    :    Tuple			,		UpperCamelCase__    :    Tuple			,		UpperCamelCase__    :    List[Any]			,		UpperCamelCase__    :    Optional[Any]			,		UpperCamelCase__    :    str			,		UpperCamelCase__    :    Optional[Any]			,		UpperCamelCase__    :    int):






           '''simple docstring'''







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



    def 					__magic_name__							(      self    :    Tuple):






           '''simple docstring'''







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


@require_tf
class    _lowerCAmelCase			(		lowercase_     ,      lowercase_     ,      unittest.TestCase      ):



    """simple docstring"""



    _lowercase				:   Tuple      =  (
        (
            TFEsmModel,
            TFEsmForMaskedLM,
            TFEsmForSequenceClassification,
            TFEsmForTokenClassification,
        )
        if is_tf_available()
        else ()
    )
    _lowercase				:   List[str]      =  (
        {
            '''feature-extraction''': TFEsmModel,
            '''fill-mask''': TFEsmForMaskedLM,
            '''text-classification''': TFEsmForSequenceClassification,
            '''token-classification''': TFEsmForTokenClassification,
            '''zero-shot''': TFEsmForSequenceClassification,
        }
        if is_tf_available()
        else {}
    )
    _lowercase				:   Tuple      =  False
    _lowercase				:   Optional[int]      =  False



    def 					__magic_name__							(      self    :    Optional[int]):






           '''simple docstring'''







           snake_case__	  =       TFEsmModelTester(self)
           snake_case__	  =       ConfigTester(self			,		config_class=UpperCamelCase__			,		hidden_size=3_7)



    def 					__magic_name__							(      self    :    str):






           '''simple docstring'''







           self.config_tester.run_common_tests()



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






           '''simple docstring'''







           snake_case__	  =       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*UpperCamelCase__)



    def 					__magic_name__							(      self    :    Dict):






           '''simple docstring'''







           snake_case__	  =       self.model_tester.prepare_config_and_inputs_for_decoder()
           self.model_tester.create_and_check_model_as_decoder(*UpperCamelCase__)



    def 					__magic_name__							(      self    :    Optional[Any]):






           '''simple docstring'''







           snake_case__	  =       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_masked_lm(*UpperCamelCase__)



    def 					__magic_name__							(      self    :    int):






           '''simple docstring'''







           snake_case__	  =       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_token_classification(*UpperCamelCase__)



    @slow
    def 					__magic_name__							(      self    :    List[str]):






           '''simple docstring'''







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



    @unittest.skip("""Protein models do not support embedding resizing.""")
    def 					__magic_name__							(      self    :    Union[str, Any]):






           '''simple docstring'''







           pass



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






           '''simple docstring'''







           pass



    def 					__magic_name__							(      self    :    Dict):






           '''simple docstring'''







           snake_case__  , snake_case__	  =       self.model_tester.prepare_config_and_inputs_for_common()

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


@require_tf
class    _lowerCAmelCase			(		unittest.TestCase      ):



    """simple docstring"""



    @slow
    def 					__magic_name__							(      self    :    Dict):






           '''simple docstring'''







           snake_case__	  =       TFEsmForMaskedLM.from_pretrained("""facebook/esm2_t6_8M_UR50D""")

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






           '''simple docstring'''







           snake_case__	  =       TFEsmModel.from_pretrained("""facebook/esm2_t6_8M_UR50D""")

           snake_case__	  =       tf.constant([[0, 6, 4, 1_3, 5, 4, 1_6, 1_2, 1_1, 7, 2]])
           snake_case__	  =       model(UpperCamelCase__)[0]
           # compare the actual values for a slice.
           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 requests
from bsa import BeautifulSoup

def _UpperCAmelCase   (	a						:	str  ,					a						:	dict ):
							snake_case__	  =       BeautifulSoup(requests.get(a  ,					params=a ).content  ,					"""html.parser""" )
							snake_case__	  =       soup.find("""div"""  ,					attrs={"""class""": """gs_ri"""} )
							snake_case__	  =       div.find("""div"""  ,					attrs={"""class""": """gs_fl"""} ).find_all("""a""" )
							return anchors[2].get_text()


if __name__ == "__main__":
	a__       =     {
	    """title""": (
	        """Precisely geometry controlled microsupercapacitors for ultrahigh areal """
	        """capacitance, volumetric capacitance, and energy density"""
	    ),
	    """journal""": """Chem. Mater.""",
	    """volume""": 3_0,
	    """pages""": """3979-3990""",
	    """year""": 2_0_1_8,
	    """hl""": """en""",
	}
	print(get_citation("""https://scholar.google.com/scholar_lookup""", params=params))
