


import unittest

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

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


if is_torch_available():
     import torch

     from transformers import (
         RemBertConfig,
         RemBertForCausalLM,
         RemBertForMaskedLM,
         RemBertForMultipleChoice,
         RemBertForQuestionAnswering,
         RemBertForSequenceClassification,
         RemBertForTokenClassification,
         RemBertModel,
     )
     from transformers.models.rembert.modeling_rembert import REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST







class 	_snake_case						:




 def __init__(	self      ,						_lowerCamelCase      ,						_lowerCamelCase=13      ,						_lowerCamelCase=7      ,						_lowerCamelCase=True      ,						_lowerCamelCase=True      ,						_lowerCamelCase=True      ,						_lowerCamelCase=True      ,						_lowerCamelCase=99      ,						_lowerCamelCase=32      ,						_lowerCamelCase=18      ,						_lowerCamelCase=43      ,						_lowerCamelCase=5      ,						_lowerCamelCase=4      ,						_lowerCamelCase=37      ,						_lowerCamelCase="gelu"      ,						_lowerCamelCase=0.1      ,						_lowerCamelCase=0.1      ,						_lowerCamelCase=512      ,						_lowerCamelCase=16      ,						_lowerCamelCase=2      ,						_lowerCamelCase=0.02      ,						_lowerCamelCase=3      ,						_lowerCamelCase=4      ,						_lowerCamelCase=None      ,						):
       a		:Optional[int]											= parent
       a		:Any											= batch_size
       a		:Dict											= seq_length
       a		:List[Any]											= is_training
       a		:int											= use_input_mask
       a		:List[Any]											= use_token_type_ids
       a		:Dict											= use_labels
       a		:Union[str, Any]											= vocab_size
       a		:List[str]											= hidden_size
       a		:int											= input_embedding_size
       a		:Any											= output_embedding_size
       a		:List[str]											= num_hidden_layers
       a		:Union[str, Any]											= num_attention_heads
       a		:Optional[Any]											= intermediate_size
       a		:Dict											= hidden_act
       a		:List[Any]											= hidden_dropout_prob
       a		:str											= attention_probs_dropout_prob
       a		:int											= max_position_embeddings
       a		:Union[str, Any]											= type_vocab_size
       a		:List[str]											= type_sequence_label_size
       a		:Optional[Any]											= initializer_range
       a		:List[Any]											= num_labels
       a		:Union[str, Any]											= num_choices
       a		:Optional[Any]											= scope




 def  SCREAMING_SNAKE_CASE__       (	self					):
       a		:Optional[int]											= ids_tensor([self.batch_size, self.seq_length]      ,						self.vocab_size					)

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

       a		:Optional[Any]											= None
       if self.use_token_type_ids:
             a		:Tuple											= ids_tensor([self.batch_size, self.seq_length]      ,						self.type_vocab_size					)

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

       a		:str											= RemBertConfig(
           vocab_size=self.vocab_size      ,						hidden_size=self.hidden_size      ,						input_embedding_size=self.input_embedding_size      ,						output_embedding_size=self.output_embedding_size      ,						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      ,						is_decoder=_lowerCamelCase      ,						initializer_range=self.initializer_range      ,						)

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




 def  SCREAMING_SNAKE_CASE__       (	self					):
       (
           (
           a
       )							,       (
           a
       )							,       (
           a
       )							,       (
           a
       )							,       (
           a
       )							,       (
           a
       )							,       (
           a
       )							,       
       )		:List[str]											= self.prepare_config_and_inputs()

       a		:List[str]											= True
       a		:List[str]											= floats_tensor([self.batch_size, self.seq_length, self.hidden_size]					)
       a		:Union[str, Any]											= ids_tensor([self.batch_size, self.seq_length]      ,						vocab_size=2					)

       return (
           config,
           input_ids,
           token_type_ids,
           input_mask,
           sequence_labels,
           token_labels,
           choice_labels,
           encoder_hidden_states,
           encoder_attention_mask,
       )




 def  SCREAMING_SNAKE_CASE__       (	self      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase					):
       a		:int											= RemBertModel(config=_lowerCamelCase					)
       model.to(_lowerCamelCase					)
       model.eval()
       a		:Optional[int]											= model(_lowerCamelCase      ,						attention_mask=_lowerCamelCase      ,						token_type_ids=_lowerCamelCase					)
       a		:List[str]											= model(_lowerCamelCase      ,						token_type_ids=_lowerCamelCase					)
       a		:Union[str, Any]											= model(_lowerCamelCase					)
       self.parent.assertEqual(result.last_hidden_state.shape      ,						(self.batch_size, self.seq_length, self.hidden_size)					)




 def  SCREAMING_SNAKE_CASE__       (	self      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						):
       a		:Any											= True
       a		:Union[str, Any]											= RemBertModel(_lowerCamelCase					)
       model.to(_lowerCamelCase					)
       model.eval()
       a		:List[Any]											= model(
           _lowerCamelCase      ,						attention_mask=_lowerCamelCase      ,						token_type_ids=_lowerCamelCase      ,						encoder_hidden_states=_lowerCamelCase      ,						encoder_attention_mask=_lowerCamelCase      ,						)
       a		:List[str]											= model(
           _lowerCamelCase      ,						attention_mask=_lowerCamelCase      ,						token_type_ids=_lowerCamelCase      ,						encoder_hidden_states=_lowerCamelCase      ,						)
       a		:Tuple											= model(_lowerCamelCase      ,						attention_mask=_lowerCamelCase      ,						token_type_ids=_lowerCamelCase					)
       self.parent.assertEqual(result.last_hidden_state.shape      ,						(self.batch_size, self.seq_length, self.hidden_size)					)




 def  SCREAMING_SNAKE_CASE__       (	self      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						):
       a		:List[Any]											= RemBertForCausalLM(config=_lowerCamelCase					)
       model.to(_lowerCamelCase					)
       model.eval()
       a		:Dict											= model(_lowerCamelCase      ,						attention_mask=_lowerCamelCase      ,						token_type_ids=_lowerCamelCase      ,						labels=_lowerCamelCase					)
       self.parent.assertEqual(result.logits.shape      ,						(self.batch_size, self.seq_length, self.vocab_size)					)




 def  SCREAMING_SNAKE_CASE__       (	self      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase					):
       a		:List[str]											= RemBertForMaskedLM(config=_lowerCamelCase					)
       model.to(_lowerCamelCase					)
       model.eval()
       a		:Union[str, Any]											= model(_lowerCamelCase      ,						attention_mask=_lowerCamelCase      ,						token_type_ids=_lowerCamelCase      ,						labels=_lowerCamelCase					)
       self.parent.assertEqual(result.logits.shape      ,						(self.batch_size, self.seq_length, self.vocab_size)					)




 def  SCREAMING_SNAKE_CASE__       (	self      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						):
       a		:int											= True
       a		:Optional[int]											= True
       a		:List[str]											= RemBertForCausalLM(config=_lowerCamelCase					)
       model.to(_lowerCamelCase					)
       model.eval()

       # first forward pass
       a		:List[Any]											= model(
           _lowerCamelCase      ,						attention_mask=_lowerCamelCase      ,						encoder_hidden_states=_lowerCamelCase      ,						encoder_attention_mask=_lowerCamelCase      ,						use_cache=_lowerCamelCase      ,						)
       a		:List[str]											= outputs.past_key_values

       # create hypothetical multiple next token and extent to next_input_ids
       a		:Tuple											= ids_tensor((self.batch_size, 3)      ,						config.vocab_size					)
       a		:Dict											= ids_tensor((self.batch_size, 3)      ,						vocab_size=2					)

       # append to next input_ids and
       a		:List[str]											= torch.cat([input_ids, next_tokens]      ,						dim=-1					)
       a		:Optional[int]											= torch.cat([input_mask, next_mask]      ,						dim=-1					)

       a		:Union[str, Any]											= model(
           _lowerCamelCase      ,						attention_mask=_lowerCamelCase      ,						encoder_hidden_states=_lowerCamelCase      ,						encoder_attention_mask=_lowerCamelCase      ,						output_hidden_states=_lowerCamelCase      ,						)['''hidden_states'''][0]
       a		:Optional[int]											= model(
           _lowerCamelCase      ,						attention_mask=_lowerCamelCase      ,						encoder_hidden_states=_lowerCamelCase      ,						encoder_attention_mask=_lowerCamelCase      ,						past_key_values=_lowerCamelCase      ,						output_hidden_states=_lowerCamelCase      ,						)['''hidden_states'''][0]

       # select random slice
       a		:Tuple											= ids_tensor((1,)      ,						output_from_past.shape[-1]					).item()
       a		:str											= output_from_no_past[:, -3:, random_slice_idx].detach()
       a		:Any											= output_from_past[:, :, random_slice_idx].detach()

       self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]					)

       # test that outputs are equal for slice
       self.parent.assertTrue(torch.allclose(_lowerCamelCase      ,						_lowerCamelCase      ,						atol=1e-3					)					)




 def  SCREAMING_SNAKE_CASE__       (	self      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase					):
       a		:str											= RemBertForQuestionAnswering(config=_lowerCamelCase					)
       model.to(_lowerCamelCase					)
       model.eval()
       a		:Optional[int]											= model(
           _lowerCamelCase      ,						attention_mask=_lowerCamelCase      ,						token_type_ids=_lowerCamelCase      ,						start_positions=_lowerCamelCase      ,						end_positions=_lowerCamelCase      ,						)
       self.parent.assertEqual(result.start_logits.shape      ,						(self.batch_size, self.seq_length)					)
       self.parent.assertEqual(result.end_logits.shape      ,						(self.batch_size, self.seq_length)					)




 def  SCREAMING_SNAKE_CASE__       (	self      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase					):
       a		:Optional[Any]											= self.num_labels
       a		:int											= RemBertForSequenceClassification(_lowerCamelCase					)
       model.to(_lowerCamelCase					)
       model.eval()
       a		:List[str]											= model(_lowerCamelCase      ,						attention_mask=_lowerCamelCase      ,						token_type_ids=_lowerCamelCase      ,						labels=_lowerCamelCase					)
       self.parent.assertEqual(result.logits.shape      ,						(self.batch_size, self.num_labels)					)




 def  SCREAMING_SNAKE_CASE__       (	self      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase					):
       a		:Tuple											= self.num_labels
       a		:Optional[Any]											= RemBertForTokenClassification(config=_lowerCamelCase					)
       model.to(_lowerCamelCase					)
       model.eval()
       a		:str											= model(_lowerCamelCase      ,						attention_mask=_lowerCamelCase      ,						token_type_ids=_lowerCamelCase      ,						labels=_lowerCamelCase					)
       self.parent.assertEqual(result.logits.shape      ,						(self.batch_size, self.seq_length, self.num_labels)					)




 def  SCREAMING_SNAKE_CASE__       (	self      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase					):
       a		:int											= self.num_choices
       a		:List[Any]											= RemBertForMultipleChoice(config=_lowerCamelCase					)
       model.to(_lowerCamelCase					)
       model.eval()
       a		:Union[str, Any]											= input_ids.unsqueeze(1					).expand(-1      ,						self.num_choices      ,						-1					).contiguous()
       a		:List[Any]											= token_type_ids.unsqueeze(1					).expand(-1      ,						self.num_choices      ,						-1					).contiguous()
       a		:List[Any]											= input_mask.unsqueeze(1					).expand(-1      ,						self.num_choices      ,						-1					).contiguous()
       a		:Union[str, Any]											= model(
           _lowerCamelCase      ,						attention_mask=_lowerCamelCase      ,						token_type_ids=_lowerCamelCase      ,						labels=_lowerCamelCase      ,						)
       self.parent.assertEqual(result.logits.shape      ,						(self.batch_size, self.num_choices)					)




 def  SCREAMING_SNAKE_CASE__       (	self					):
       a		:int											= self.prepare_config_and_inputs()
       (
           (
           a
       )							,       (
           a
       )							,       (
           a
       )							,       (
           a
       )							,       (
           a
       )							,       (
           a
       )							,       (
           a
       )							,       
       )		:Union[str, Any]											= config_and_inputs
       a		:Any											= {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
       return config, inputs_dict







@require_torch
class 	_snake_case						(   _snake_case		,					_snake_case		,					unittest.TestCase							):
 SCREAMING_SNAKE_CASE__   = (
     (
         RemBertModel,
         RemBertForMaskedLM,
         RemBertForCausalLM,
         RemBertForMultipleChoice,
         RemBertForQuestionAnswering,
         RemBertForSequenceClassification,
         RemBertForTokenClassification,
     )
     if is_torch_available()
     else ()
 )
 SCREAMING_SNAKE_CASE__   = (RemBertForCausalLM,) if is_torch_available() else ()
 SCREAMING_SNAKE_CASE__   = (
     {
         'feature-extraction': RemBertModel,
         'fill-mask': RemBertForMaskedLM,
         'question-answering': RemBertForQuestionAnswering,
         'text-classification': RemBertForSequenceClassification,
         'text-generation': RemBertForCausalLM,
         'token-classification': RemBertForTokenClassification,
         'zero-shot': RemBertForSequenceClassification,
     }
     if is_torch_available()
     else {}
 )




 def  SCREAMING_SNAKE_CASE__       (	self					):
       a		:List[Any]											= RemBertModelTester(self					)
       a		:str											= ConfigTester(self      ,						config_class=_lowerCamelCase      ,						hidden_size=37					)




 def  SCREAMING_SNAKE_CASE__       (	self					):
       self.config_tester.run_common_tests()




 def  SCREAMING_SNAKE_CASE__       (	self					):
       a		:Any											= self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_lowerCamelCase					)




 def  SCREAMING_SNAKE_CASE__       (	self					):
       a		:Any											= self.model_tester.prepare_config_and_inputs()
       for type in ["absolute", "relative_key", "relative_key_query"]:
             a		:List[Any]											= type
             self.model_tester.create_and_check_model(*_lowerCamelCase					)




 def  SCREAMING_SNAKE_CASE__       (	self					):
       a		:Any											= self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_lm(*_lowerCamelCase					)




 def  SCREAMING_SNAKE_CASE__       (	self					):
       a		:List[Any]											= self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_multiple_choice(*_lowerCamelCase					)




 def  SCREAMING_SNAKE_CASE__       (	self					):
       a		:Union[str, Any]											= self.model_tester.prepare_config_and_inputs_for_decoder()
       self.model_tester.create_and_check_decoder_model_past_large_inputs(*_lowerCamelCase					)




 def  SCREAMING_SNAKE_CASE__       (	self					):
       a		:Tuple											= self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_question_answering(*_lowerCamelCase					)




 def  SCREAMING_SNAKE_CASE__       (	self					):
       a		:str											= self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_sequence_classification(*_lowerCamelCase					)




 def  SCREAMING_SNAKE_CASE__       (	self					):
       a		:List[str]											= self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_token_classification(*_lowerCamelCase					)




 def  SCREAMING_SNAKE_CASE__       (	self					):
       a		:Dict											= self.model_tester.prepare_config_and_inputs_for_decoder()
       self.model_tester.create_and_check_model_as_decoder(*_lowerCamelCase					)




 def  SCREAMING_SNAKE_CASE__       (	self					):
       # This regression test was failing with PyTorch < 1.3
       (
           (
           a
       )							,       (
           a
       )							,       (
           a
       )							,       (
           a
       )							,       (
           a
       )							,       (
           a
       )							,       (
           a
       )							,       (
           a
       )							,       (
           a
       )							,       
       )		:int											= self.model_tester.prepare_config_and_inputs_for_decoder()

       a		:str											= None

       self.model_tester.create_and_check_model_as_decoder(
           _lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase      ,						)




 @slow
 def  SCREAMING_SNAKE_CASE__       (	self					):
       for model_name in REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             a		:Dict											= RemBertModel.from_pretrained(_lowerCamelCase					)
             self.assertIsNotNone(_lowerCamelCase					)







@require_torch
class 	_snake_case						(   unittest.TestCase							):




 @slow
 def  SCREAMING_SNAKE_CASE__       (	self					):
       # Test exact values at the last hidden layer
       a		:Optional[Any]											= RemBertModel.from_pretrained('''google/rembert'''					)
       a		:Union[str, Any]											= torch.tensor([[312, 5_6498, 313, 2125, 313]]					)
       a		:Optional[Any]											= torch.tensor([[0, 0, 0, 1, 1]]					)
       with torch.no_grad():
             a		:Union[str, Any]											= model(_lowerCamelCase      ,						token_type_ids=_lowerCamelCase      ,						output_hidden_states=_lowerCamelCase					)

       a		:Optional[int]											= 1152

       a		:Optional[int]											= torch.Size((1, 5, hidden_size)					)
       self.assertEqual(output['''last_hidden_state'''].shape      ,						_lowerCamelCase					)

       a		:Optional[int]											= torch.tensor(
           [
               [
                   [0.0754, -0.2022, 0.1904],
                   [-0.3354, -0.3692, -0.4791],
                   [-0.2314, -0.6729, -0.0749],
                   [-0.0396, -0.3105, -0.4234],
                   [-0.1571, -0.0525, 0.5353],
               ]
           ]					)

       # Running on the original tf implementation gives slightly different results here.
       # Not clear why this variations is present
       # TODO: Find reason for discrepancy
       # expected_original_implementation = [[
       #     [0.07630594074726105, -0.20146065950393677, 0.19107051193714142],
       #     [-0.3405614495277405, -0.36971670389175415, -0.4808273911476135],
       #     [-0.22587086260318756, -0.6656315922737122, -0.07844287157058716],
       #     [-0.04145475849509239, -0.3077218234539032, -0.42316967248916626],
       #     [-0.15887849032878876, -0.054529931396245956, 0.5356100797653198]
       # ]]

       self.assertTrue(torch.allclose(output['''last_hidden_state'''][:, :, :3]      ,						_lowerCamelCase      ,						atol=1e-4					)					)









from typing import Optional, Union

from ...file_utils import TensorType
from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, TruncationStrategy







class 	_snake_case						(   _snake_case							):
 SCREAMING_SNAKE_CASE__   = 'MarkupLMFeatureExtractor'
 SCREAMING_SNAKE_CASE__   = ('MarkupLMTokenizer', 'MarkupLMTokenizerFast')
 SCREAMING_SNAKE_CASE__   = True




 def __call__(	self      ,						_lowerCamelCase=None      ,						_lowerCamelCase=None      ,						_lowerCamelCase=None      ,						_lowerCamelCase=None      ,						_lowerCamelCase=None      ,						_lowerCamelCase = True      ,						_lowerCamelCase = False      ,						_lowerCamelCase = None      ,						_lowerCamelCase = None      ,						_lowerCamelCase = 0      ,						_lowerCamelCase = None      ,						_lowerCamelCase = None      ,						_lowerCamelCase = None      ,						_lowerCamelCase = False      ,						_lowerCamelCase = False      ,						_lowerCamelCase = False      ,						_lowerCamelCase = False      ,						_lowerCamelCase = True      ,						_lowerCamelCase = None      ,						**_lowerCamelCase      ,						):
       # first, create nodes and xpaths
       if self.parse_html:
             if html_strings is None:
                   raise ValueError('''Make sure to pass HTML strings in case `parse_html` is set to `True`'''					)

             if nodes is not None or xpaths is not None or node_labels is not None:
                   raise ValueError(
                       '''Please don\'t pass nodes, xpaths nor node labels in case `parse_html` is set to `True`'''					)

             a		:int											= self.feature_extractor(_lowerCamelCase					)
             a		:Tuple											= features['''nodes''']
             a		:Dict											= features['''xpaths''']
       else:
             if html_strings is not None:
                   raise ValueError('''You have passed HTML strings but `parse_html` is set to `False`.'''					)
             if nodes is None or xpaths is None:
                   raise ValueError('''Make sure to pass nodes and xpaths in case `parse_html` is set to `False`'''					)

        # # second, apply the tokenizer
       if questions is not None and self.parse_html:
             if isinstance(_lowerCamelCase      ,						_lowerCamelCase					):
                   a		:Tuple											= [questions]  # add batch dimension (as the feature extractor always adds a batch dimension)

       a		:Optional[int]											= self.tokenizer(
           text=questions if questions is not None else nodes      ,						text_pair=nodes if questions is not None else None      ,						xpaths=_lowerCamelCase      ,						node_labels=_lowerCamelCase      ,						add_special_tokens=_lowerCamelCase      ,						padding=_lowerCamelCase      ,						truncation=_lowerCamelCase      ,						max_length=_lowerCamelCase      ,						stride=_lowerCamelCase      ,						pad_to_multiple_of=_lowerCamelCase      ,						return_token_type_ids=_lowerCamelCase      ,						return_attention_mask=_lowerCamelCase      ,						return_overflowing_tokens=_lowerCamelCase      ,						return_special_tokens_mask=_lowerCamelCase      ,						return_offsets_mapping=_lowerCamelCase      ,						return_length=_lowerCamelCase      ,						verbose=_lowerCamelCase      ,						return_tensors=_lowerCamelCase      ,						**_lowerCamelCase      ,						)

       return encoded_inputs




 def  SCREAMING_SNAKE_CASE__       (	self      ,						*_lowerCamelCase      ,						**_lowerCamelCase					):
       return self.tokenizer.batch_decode(*_lowerCamelCase      ,						**_lowerCamelCase					)




 def  SCREAMING_SNAKE_CASE__       (	self      ,						*_lowerCamelCase      ,						**_lowerCamelCase					):
       return self.tokenizer.decode(*_lowerCamelCase      ,						**_lowerCamelCase					)




 @property
 def  SCREAMING_SNAKE_CASE__       (	self					):
       a		:Any											= self.tokenizer.model_input_names
       return tokenizer_input_names





