
'''simple docstring'''







import unittest

from transformers import EsmConfig, is_torch_available
from transformers.testing_utils import TestCasePlus, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
					import torch

					from transformers import EsmForMaskedLM, EsmForSequenceClassification, EsmForTokenClassification, EsmModel
					from transformers.models.esm.modeling_esm import (
					    ESM_PRETRAINED_MODEL_ARCHIVE_LIST,
					    EsmEmbeddings,
					    create_position_ids_from_input_ids,
					)


class 		__UpperCAmelCase   :


							def __init__( self					,     lowerCAmelCase_					,     lowerCAmelCase_=13					,     lowerCAmelCase_=7					,     lowerCAmelCase_=False					,     lowerCAmelCase_=True					,     lowerCAmelCase_=False					,     lowerCAmelCase_=True					,     lowerCAmelCase_=33					,     lowerCAmelCase_=32					,     lowerCAmelCase_=5					,     lowerCAmelCase_=4					,     lowerCAmelCase_=37					,     lowerCAmelCase_="gelu"					,     lowerCAmelCase_=0.1					,     lowerCAmelCase_=0.1					,     lowerCAmelCase_=5_12					,     lowerCAmelCase_=16					,     lowerCAmelCase_=2					,     lowerCAmelCase_=0.02					,     lowerCAmelCase_=3					,     lowerCAmelCase_=4					,     lowerCAmelCase_=None					,     ):





								"""simple docstring"""






								_snake_case     		=	parent
								_snake_case     		=	batch_size
								_snake_case     		=	seq_length
								_snake_case     		=	is_training
								_snake_case     		=	use_input_mask
								_snake_case     		=	use_token_type_ids
								_snake_case     		=	use_labels
								_snake_case     		=	vocab_size
								_snake_case     		=	hidden_size
								_snake_case     		=	num_hidden_layers
								_snake_case     		=	num_attention_heads
								_snake_case     		=	intermediate_size
								_snake_case     		=	hidden_act
								_snake_case     		=	hidden_dropout_prob
								_snake_case     		=	attention_probs_dropout_prob
								_snake_case     		=	max_position_embeddings
								_snake_case     		=	type_vocab_size
								_snake_case     		=	type_sequence_label_size
								_snake_case     		=	initializer_range
								_snake_case     		=	num_labels
								_snake_case     		=	num_choices
								_snake_case     		=	scope


							def 				lowerCamelCase       ( self						):





								"""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     		=	self.get_config()

								return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								return EsmConfig(
								    vocab_size=self.vocab_size					,     hidden_size=self.hidden_size					,     pad_token_id=1					,     num_hidden_layers=self.num_hidden_layers					,     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					,     )


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_						):





								"""simple docstring"""






								_snake_case     		=	EsmModel(config=lowerCAmelCase_						)
								model.to(lowerCAmelCase_						)
								model.eval()
								_snake_case     		=	model(lowerCAmelCase_					,     attention_mask=lowerCAmelCase_						)
								_snake_case     		=	model(lowerCAmelCase_						)
								_snake_case     		=	model(lowerCAmelCase_						)

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


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_						):





								"""simple docstring"""






								_snake_case     		=	EsmForMaskedLM(config=lowerCAmelCase_						)
								model.to(lowerCAmelCase_						)
								model.eval()
								_snake_case     		=	model(lowerCAmelCase_					,     attention_mask=lowerCAmelCase_					,     labels=lowerCAmelCase_						)
								self.parent.assertEqual(result.logits.shape					,     (self.batch_size, self.seq_length, self.vocab_size)						)


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_						):





								"""simple docstring"""






								_snake_case     		=	self.num_labels
								_snake_case     		=	EsmForTokenClassification(config=lowerCAmelCase_						)
								model.to(lowerCAmelCase_						)
								model.eval()
								_snake_case     		=	model(lowerCAmelCase_					,     attention_mask=lowerCAmelCase_					,     labels=lowerCAmelCase_						)
								self.parent.assertEqual(result.logits.shape					,     (self.batch_size, self.seq_length, self.num_labels)						)




							def 				lowerCamelCase       ( self						):





								"""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_torch
class 		__UpperCAmelCase   (      _lowerCamelCase		,     _lowerCamelCase		,     unittest.TestCase		):
							__lowercase   	= False

							__lowercase   	= (
							    (
							        EsmForMaskedLM,
							        EsmModel,
							        EsmForSequenceClassification,
							        EsmForTokenClassification,
							    )
							    if is_torch_available()
							    else ()
							)
							__lowercase   	= ()
							__lowercase   	= (
							    {
							        """feature-extraction""": EsmModel,
							        """fill-mask""": EsmForMaskedLM,
							        """text-classification""": EsmForSequenceClassification,
							        """token-classification""": EsmForTokenClassification,
							        """zero-shot""": EsmForSequenceClassification,
							    }
							    if is_torch_available()
							    else {}
							)
							__lowercase   	= True


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	EsmModelTester(self						)
								_snake_case     		=	ConfigTester(self					,     config_class=lowerCAmelCase_					,     hidden_size=37						)


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								self.config_tester.run_common_tests()


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*lowerCAmelCase_						)


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	self.model_tester.prepare_config_and_inputs()
								for type in ["absolute", "relative_key", "relative_key_query"]:
									_snake_case     		=	type
									self.model_tester.create_and_check_model(*lowerCAmelCase_						)


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_masked_lm(*lowerCAmelCase_						)


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_token_classification(*lowerCAmelCase_						)


							@slow
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								for model_name in ESM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									_snake_case     		=	EsmModel.from_pretrained(lowerCAmelCase_						)
									self.assertIsNotNone(lowerCAmelCase_						)


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	self.model_tester.prepare_config_and_inputs()[0]
								_snake_case     		=	EsmEmbeddings(config=lowerCAmelCase_						)

								_snake_case     		=	torch.as_tensor([[12, 31, 13, model.padding_idx]]						)
								_snake_case     		=	torch.as_tensor(
								    [
								        [
								            0 + model.padding_idx + 1,
								            1 + model.padding_idx + 1,
								            2 + model.padding_idx + 1,
								            model.padding_idx,
								        ]
								    ]						)
								_snake_case     		=	create_position_ids_from_input_ids(lowerCAmelCase_					,     model.padding_idx						)
								self.assertEqual(position_ids.shape					,     expected_positions.shape						)
								self.assertTrue(torch.all(torch.eq(lowerCAmelCase_					,     lowerCAmelCase_						)						)						)


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	self.model_tester.prepare_config_and_inputs()[0]
								_snake_case     		=	EsmEmbeddings(config=lowerCAmelCase_						)

								_snake_case     		=	torch.empty(2					,     4					,     30						)
								_snake_case     		=	[
								    0 + embeddings.padding_idx + 1,
								    1 + embeddings.padding_idx + 1,
								    2 + embeddings.padding_idx + 1,
								    3 + embeddings.padding_idx + 1,
								]
								_snake_case     		=	torch.as_tensor([expected_single_positions, expected_single_positions]						)
								_snake_case     		=	embeddings.create_position_ids_from_inputs_embeds(lowerCAmelCase_						)
								self.assertEqual(position_ids.shape					,     expected_positions.shape						)
								self.assertTrue(torch.all(torch.eq(lowerCAmelCase_					,     lowerCAmelCase_						)						)						)


							@unittest.skip('Esm does not support embedding resizing'						)
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								pass


							@unittest.skip('Esm does not support embedding resizing'						)
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								pass




							@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'						)
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								pass


@require_torch
class 		__UpperCAmelCase   (      _lowerCamelCase		):


							@slow
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								with torch.no_grad():
									_snake_case     		=	EsmForMaskedLM.from_pretrained('facebook/esm2_t6_8M_UR50D'						)
									model.eval()
									_snake_case     		=	torch.tensor([[0, 1, 2, 3, 4, 5]]						)
									_snake_case     		=	model(lowerCAmelCase_						)[0]

									_snake_case     		=	33

									_snake_case     		=	torch.Size((1, 6, vocab_size)						)
									self.assertEqual(output.shape					,     lowerCAmelCase_						)

									_snake_case     		=	torch.tensor(
									    [[[8.9215, -10.5898, -6.4671], [-6.3967, -13.9114, -1.1212], [-7.7812, -13.9516, -3.7406]]]						)
									self.assertTrue(torch.allclose(output[:, :3, :3]					,     lowerCAmelCase_					,     atol=1E-4						)						)




							@slow
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								with torch.no_grad():
									_snake_case     		=	EsmModel.from_pretrained('facebook/esm2_t6_8M_UR50D'						)
									model.eval()

									_snake_case     		=	torch.tensor([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]]						)
									_snake_case     		=	model(lowerCAmelCase_						)[0]
									# compare the actual values for a slice.
									_snake_case     		=	torch.tensor(
									    [[[0.1444, 0.5413, 0.3248], [0.3034, 0.0053, 0.3108], [0.3228, -0.2499, 0.3415]]]						)
									self.assertTrue(torch.allclose(output[:, :3, :3]					,     lowerCAmelCase_					,     atol=1E-4						)						)



'''simple docstring'''







from typing import List, Optional

from tokenizers import ByteLevelBPETokenizer

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_blenderbot_small import BlenderbotSmallTokenizer


lowercase					:							Optional[Any]   =      logging.get_logger(__name__)

lowercase					:							str   =      {
    "vocab_file": "vocab.json",
    "merges_file": "merges.txt",
    "tokenizer_config_file": "tokenizer_config.json",
}

lowercase					:							Optional[Any]   =      {
    "vocab_file": {
        "facebook/blenderbot_small-90M": "https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/vocab.json"
    },
    "merges_file": {
        "facebook/blenderbot_small-90M": "https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/merges.txt"
    },
    "tokenizer_config_file": {
        "facebook/blenderbot_small-90M": (
            "https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/tokenizer_config.json"
        )
    },
}

lowercase					:							List[Any]   =      {
    "facebook/blenderbot_small-90M": 512,
}


class 		__UpperCAmelCase   (      _lowerCamelCase		):
							__lowercase   	= VOCAB_FILES_NAMES
							__lowercase   	= PRETRAINED_VOCAB_FILES_MAP
							__lowercase   	= PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
							__lowercase   	= BlenderbotSmallTokenizer


							def __init__( self					,     lowerCAmelCase_=None					,     lowerCAmelCase_=None					,     lowerCAmelCase_="<|endoftext|>"					,     lowerCAmelCase_="<|endoftext|>"					,     lowerCAmelCase_="<|endoftext|>"					,     lowerCAmelCase_=False					,     lowerCAmelCase_=True					,     **lowerCAmelCase_					,     ):





								"""simple docstring"""






								super().__init__(
								    ByteLevelBPETokenizer(
								        vocab=lowerCAmelCase_					,     merges=lowerCAmelCase_					,     add_prefix_space=lowerCAmelCase_					,     trim_offsets=lowerCAmelCase_					,     )					,     bos_token=lowerCAmelCase_					,     eos_token=lowerCAmelCase_					,     unk_token=lowerCAmelCase_					,     **lowerCAmelCase_					,     )
								_snake_case     		=	add_prefix_space


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_=None						):





								"""simple docstring"""






								_snake_case     		=	[self.bos_token_id] + token_ids_a + [self.eos_token_id]
								if token_ids_a is None:
									return output

								return output + [self.eos_token_id] + token_ids_a + [self.eos_token_id]




							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_ = None						):





								"""simple docstring"""






								_snake_case     		=	[self.sep_token_id]
								_snake_case     		=	[self.cls_token_id]

								if token_ids_a is None:
									return len(cls + token_ids_a + sep						) * [0]
								return len(cls + token_ids_a + sep + sep + token_ids_a + sep						) * [0]

