code: 
  import unittest
  
  from transformers import ElectraConfig, is_torch_available
  from transformers.models.auto import get_values
  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 (
  				    MODEL_FOR_PRETRAINING_MAPPING,
  				    ElectraForCausalLM,
  				    ElectraForMaskedLM,
  				    ElectraForMultipleChoice,
  				    ElectraForPreTraining,
  				    ElectraForQuestionAnswering,
  				    ElectraForSequenceClassification,
  				    ElectraForTokenClassification,
  				    ElectraModel,
  				)
  				from transformers.models.electra.modeling_electra import ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST
  
  
  
  
  
  class    _snake_case      :
  
  
  
  
  
  
  
  			def __init__(       self		,     _a		,     _a=13		,     _a=7		,     _a=True		,     _a=True		,     _a=True		,     _a=True		,     _a=99		,     _a=32		,     _a=5		,     _a=4		,     _a=37		,     _a="gelu"		,     _a=0.1		,     _a=0.1		,     _a=512		,     _a=16		,     _a=2		,     _a=0.02		,     _a=3		,     _a=4		,     _a=None		,     ):
  				__magic_name__	:	Dict			     =  parent
  				__magic_name__	:	List[Any]			     =  batch_size
  				__magic_name__	:	int			     =  seq_length
  				__magic_name__	:	int			     =  is_training
  				__magic_name__	:	str			     =  use_input_mask
  				__magic_name__	:	List[str]			     =  use_token_type_ids
  				__magic_name__	:	Any			     =  use_labels
  				__magic_name__	:	List[Any]			     =  vocab_size
  				__magic_name__	:	List[str]			     =  hidden_size
  				__magic_name__	:	int			     =  num_hidden_layers
  				__magic_name__	:	Dict			     =  num_attention_heads
  				__magic_name__	:	Optional[Any]			     =  intermediate_size
  				__magic_name__	:	Dict			     =  hidden_act
  				__magic_name__	:	Any			     =  hidden_dropout_prob
  				__magic_name__	:	Dict			     =  attention_probs_dropout_prob
  				__magic_name__	:	Optional[int]			     =  max_position_embeddings
  				__magic_name__	:	Optional[Any]			     =  type_vocab_size
  				__magic_name__	:	List[Any]			     =  type_sequence_label_size
  				__magic_name__	:	List[str]			     =  initializer_range
  				__magic_name__	:	Optional[Any]			     =  num_labels
  				__magic_name__	:	str			     =  num_choices
  				__magic_name__	:	List[str]			     =  scope
  
  
  
  
  
  
  
  			def     SCREAMING_SNAKE_CASE					(       self	):
  				__magic_name__	:	Tuple			     =  ids_tensor([self.batch_size, self.seq_length]		,     self.vocab_size	)
  
  				__magic_name__	:	List[Any]			     =  None
  				if self.use_input_mask:
  					__magic_name__	:	Tuple			     =  random_attention_mask([self.batch_size, self.seq_length]	)
  
  				__magic_name__	:	List[str]			     =  None
  				if self.use_token_type_ids:
  					__magic_name__	:	List[Any]			     =  ids_tensor([self.batch_size, self.seq_length]		,     self.type_vocab_size	)
  
  				__magic_name__	:	Tuple			     =  None
  				__magic_name__	:	str			     =  None
  				__magic_name__	:	Dict			     =  None
  				if self.use_labels:
  					__magic_name__	:	List[str]			     =  ids_tensor([self.batch_size]		,     self.type_sequence_label_size	)
  					__magic_name__	:	int			     =  ids_tensor([self.batch_size, self.seq_length]		,     self.num_labels	)
  					__magic_name__	:	List[Any]			     =  ids_tensor([self.batch_size]		,     self.num_choices	)
  					__magic_name__	:	List[Any]			     =  ids_tensor([self.batch_size, self.seq_length]		,     1	)
  
  				__magic_name__	:	Any			     =  self.get_config()
  
  				return (
  				    config,
  				    input_ids,
  				    token_type_ids,
  				    input_mask,
  				    sequence_labels,
  				    token_labels,
  				    choice_labels,
  				    fake_token_labels,
  				)
  
  
  
  
  
  
  
  			def     SCREAMING_SNAKE_CASE					(       self	):
  				return ElectraConfig(
  				    vocab_size=self.vocab_size		,     hidden_size=self.hidden_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=_a		,     initializer_range=self.initializer_range		,     )
  
  
  
  
  
  
  
  			def     SCREAMING_SNAKE_CASE					(       self	):
  				(
  				    (
  				    __magic_name__
  				)     ,					(
  				    __magic_name__
  				)     ,					(
  				    __magic_name__
  				)     ,					(
  				    __magic_name__
  				)     ,					(
  				    __magic_name__
  				)     ,					(
  				    __magic_name__
  				)     ,					(
  				    __magic_name__
  				)     ,					(
  				    __magic_name__
  				)     ,					
  				)	:	Any			     =  self.prepare_config_and_inputs()
  
  				__magic_name__	:	List[str]			     =  True
  				__magic_name__	:	Any			     =  floats_tensor([self.batch_size, self.seq_length, self.hidden_size]	)
  				__magic_name__	:	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		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     ):
  				__magic_name__	:	Any			     =  ElectraModel(config=_a	)
  				model.to(_a	)
  				model.eval()
  				__magic_name__	:	Tuple			     =  model(_a		,     attention_mask=_a		,     token_type_ids=_a	)
  				__magic_name__	:	Optional[Any]			     =  model(_a		,     token_type_ids=_a	)
  				__magic_name__	:	List[Any]			     =  model(_a	)
  				self.parent.assertEqual(result.last_hidden_state.shape		,     (self.batch_size, self.seq_length, self.hidden_size)	)
  
  
  
  
  
  
  
  			def     SCREAMING_SNAKE_CASE					(       self		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     ):
  				__magic_name__	:	Tuple			     =  True
  				__magic_name__	:	List[str]			     =  ElectraModel(_a	)
  				model.to(_a	)
  				model.eval()
  				__magic_name__	:	Union[str, Any]			     =  model(
  				    _a		,     attention_mask=_a		,     token_type_ids=_a		,     encoder_hidden_states=_a		,     encoder_attention_mask=_a		,     )
  				__magic_name__	:	Optional[int]			     =  model(
  				    _a		,     attention_mask=_a		,     token_type_ids=_a		,     encoder_hidden_states=_a		,     )
  				__magic_name__	:	Optional[Any]			     =  model(_a		,     attention_mask=_a		,     token_type_ids=_a	)
  				self.parent.assertEqual(result.last_hidden_state.shape		,     (self.batch_size, self.seq_length, self.hidden_size)	)
  
  
  
  
  
  
  
  			def     SCREAMING_SNAKE_CASE					(       self		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     ):
  				__magic_name__	:	Any			     =  ElectraForMaskedLM(config=_a	)
  				model.to(_a	)
  				model.eval()
  				__magic_name__	:	List[Any]			     =  model(_a		,     attention_mask=_a		,     token_type_ids=_a		,     labels=_a	)
  				self.parent.assertEqual(result.logits.shape		,     (self.batch_size, self.seq_length, self.vocab_size)	)
  
  
  
  
  
  
  
  			def     SCREAMING_SNAKE_CASE					(       self		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     ):
  				__magic_name__	:	List[str]			     =  ElectraForCausalLM(config=_a	)
  				model.to(_a	)
  				model.eval()
  				__magic_name__	:	Tuple			     =  model(_a		,     attention_mask=_a		,     token_type_ids=_a		,     labels=_a	)
  				self.parent.assertEqual(result.logits.shape		,     (self.batch_size, self.seq_length, self.vocab_size)	)
  
  
  
  
  
  
  
  			def     SCREAMING_SNAKE_CASE					(       self		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     ):
  				__magic_name__	:	int			     =  self.num_labels
  				__magic_name__	:	List[str]			     =  ElectraForTokenClassification(config=_a	)
  				model.to(_a	)
  				model.eval()
  				__magic_name__	:	List[str]			     =  model(_a		,     attention_mask=_a		,     token_type_ids=_a		,     labels=_a	)
  				self.parent.assertEqual(result.logits.shape		,     (self.batch_size, self.seq_length, self.num_labels)	)
  
  
  
  
  
  
  
  			def     SCREAMING_SNAKE_CASE					(       self		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     ):
  				__magic_name__	:	str			     =  self.num_labels
  				__magic_name__	:	List[Any]			     =  ElectraForPreTraining(config=_a	)
  				model.to(_a	)
  				model.eval()
  				__magic_name__	:	List[Any]			     =  model(_a		,     attention_mask=_a		,     token_type_ids=_a		,     labels=_a	)
  				self.parent.assertEqual(result.logits.shape		,     (self.batch_size, self.seq_length)	)
  
  
  
  
  
  
  
  			def     SCREAMING_SNAKE_CASE					(       self		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     ):
  				__magic_name__	:	List[str]			     =  self.num_labels
  				__magic_name__	:	Dict			     =  ElectraForSequenceClassification(_a	)
  				model.to(_a	)
  				model.eval()
  				__magic_name__	:	str			     =  model(_a		,     attention_mask=_a		,     token_type_ids=_a		,     labels=_a	)
  				self.parent.assertEqual(result.logits.shape		,     (self.batch_size, self.num_labels)	)
  
  
  
  
  
  
  
  			def     SCREAMING_SNAKE_CASE					(       self		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     ):
  				__magic_name__	:	Dict			     =  ElectraForQuestionAnswering(config=_a	)
  				model.to(_a	)
  				model.eval()
  				__magic_name__	:	Tuple			     =  model(
  				    _a		,     attention_mask=_a		,     token_type_ids=_a		,     start_positions=_a		,     end_positions=_a		,     )
  				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		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     _a		,     ):
  				__magic_name__	:	str			     =  self.num_choices
  				__magic_name__	:	Union[str, Any]			     =  ElectraForMultipleChoice(config=_a	)
  				model.to(_a	)
  				model.eval()
  				__magic_name__	:	str			     =  input_ids.unsqueeze(1	).expand(-1		,     self.num_choices		,     -1	).contiguous()
  				__magic_name__	:	int			     =  token_type_ids.unsqueeze(1	).expand(-1		,     self.num_choices		,     -1	).contiguous()
  				__magic_name__	:	Dict			     =  input_mask.unsqueeze(1	).expand(-1		,     self.num_choices		,     -1	).contiguous()
  				__magic_name__	:	Union[str, Any]			     =  model(
  				    _a		,     attention_mask=_a		,     token_type_ids=_a		,     labels=_a		,     )
  				self.parent.assertEqual(result.logits.shape		,     (self.batch_size, self.num_choices)	)
  
  
  
  
  
  
  
  			def     SCREAMING_SNAKE_CASE					(       self	):
  				__magic_name__	:	Tuple			     =  self.prepare_config_and_inputs()
  				(
  				    (
  				    __magic_name__
  				)     ,					(
  				    __magic_name__
  				)     ,					(
  				    __magic_name__
  				)     ,					(
  				    __magic_name__
  				)     ,					(
  				    __magic_name__
  				)     ,					(
  				    __magic_name__
  				)     ,					(
  				    __magic_name__
  				)     ,					(
  				    __magic_name__
  				)     ,					
  				)	:	List[str]			     =  config_and_inputs
  				__magic_name__	:	Optional[int]			     =  {"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       ):
  			UpperCamelCase__					   =					(
  			    (
  			        ElectraModel,
  			        ElectraForPreTraining,
  			        ElectraForMaskedLM,
  			        ElectraForCausalLM,
  			        ElectraForMultipleChoice,
  			        ElectraForTokenClassification,
  			        ElectraForSequenceClassification,
  			        ElectraForQuestionAnswering,
  			    )
  			    if is_torch_available()
  			    else ()
  			)
  			UpperCamelCase__					   =					(
  			    {
  			        'feature-extraction': ElectraModel,
  			        'fill-mask': ElectraForMaskedLM,
  			        'question-answering': ElectraForQuestionAnswering,
  			        'text-classification': ElectraForSequenceClassification,
  			        'text-generation': ElectraForCausalLM,
  			        'token-classification': ElectraForTokenClassification,
  			        'zero-shot': ElectraForSequenceClassification,
  			    }
  			    if is_torch_available()
  			    else {}
  			)
  			UpperCamelCase__					   =					True
  
  
  
  
  
  
  
  			def     SCREAMING_SNAKE_CASE					(       self		,     _a		,     _a		,     _a=False	):
  				__magic_name__	:	Union[str, Any]			     =  super()._prepare_for_class(_a		,     _a		,     return_labels=_a	)
  
  				if return_labels:
  					if model_class in get_values(_a	):
  						__magic_name__	:	Optional[int]			     =  torch.zeros(
  						    (self.model_tester.batch_size, self.model_tester.seq_length)		,     dtype=torch.long		,     device=_a	)
  				return inputs_dict
  
  
  
  
  
  
  
  			def     SCREAMING_SNAKE_CASE					(       self	):
  				__magic_name__	:	List[Any]			     =  ElectraModelTester(self	)
  				__magic_name__	:	Optional[Any]			     =  ConfigTester(self		,     config_class=_a		,     hidden_size=37	)
  
  
  
  
  
  
  
  			def     SCREAMING_SNAKE_CASE					(       self	):
  				self.config_tester.run_common_tests()
  
  
  
  
  
  
  
  			def     SCREAMING_SNAKE_CASE					(       self	):
  				__magic_name__	:	Optional[int]			     =  self.model_tester.prepare_config_and_inputs()
  				self.model_tester.create_and_check_electra_model(*_a	)
  
  
  
  
  
  
  
  			def     SCREAMING_SNAKE_CASE					(       self	):
  				__magic_name__	:	Tuple			     =  self.model_tester.prepare_config_and_inputs_for_decoder()
  				self.model_tester.create_and_check_electra_model_as_decoder(*_a	)
  
  
  
  
  
  
  
  			def     SCREAMING_SNAKE_CASE					(       self	):
  				__magic_name__	:	Optional[int]			     =  self.model_tester.prepare_config_and_inputs()
  				for type in ["absolute", "relative_key", "relative_key_query"]:
  					__magic_name__	:	Tuple			     =  type
  					self.model_tester.create_and_check_electra_model(*_a	)
  
  
  
  
  
  
  
  			def     SCREAMING_SNAKE_CASE					(       self	):
  				__magic_name__	:	Any			     =  self.model_tester.prepare_config_and_inputs()
  				self.model_tester.create_and_check_electra_for_masked_lm(*_a	)
  
  
  
  
  
  
  
  			def     SCREAMING_SNAKE_CASE					(       self	):
  				__magic_name__	:	Dict			     =  self.model_tester.prepare_config_and_inputs()
  				self.model_tester.create_and_check_electra_for_token_classification(*_a	)
  
  
  
  
  
  
  
  			def     SCREAMING_SNAKE_CASE					(       self	):
  				__magic_name__	:	List[Any]			     =  self.model_tester.prepare_config_and_inputs()
  				self.model_tester.create_and_check_electra_for_pretraining(*_a	)
  
  
  
  
  
  
  
  			def     SCREAMING_SNAKE_CASE					(       self	):
  				__magic_name__	:	Dict			     =  self.model_tester.prepare_config_and_inputs()
  				self.model_tester.create_and_check_electra_for_sequence_classification(*_a	)
  
  
  
  
  
  
  
  			def     SCREAMING_SNAKE_CASE					(       self	):
  				__magic_name__	:	Any			     =  self.model_tester.prepare_config_and_inputs()
  				self.model_tester.create_and_check_electra_for_question_answering(*_a	)
  
  
  
  
  
  
  
  			def     SCREAMING_SNAKE_CASE					(       self	):
  				__magic_name__	:	int			     =  self.model_tester.prepare_config_and_inputs()
  				self.model_tester.create_and_check_electra_for_multiple_choice(*_a	)
  
  
  
  
  
  
  
  			@slow
  			def     SCREAMING_SNAKE_CASE					(       self	):
  				for model_name in ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
  					__magic_name__	:	Optional[int]			     =  ElectraModel.from_pretrained(_a	)
  					self.assertIsNotNone(_a	)
  
  
  
  
  
  
  
  			def     SCREAMING_SNAKE_CASE					(       self	):
  				__magic_name__	:	Tuple			     =  self.model_tester.prepare_config_and_inputs_for_decoder()
  				self.model_tester.create_and_check_electra_for_causal_lm(*_a	)
  
  
  
  
  
  
  
  @require_torch
  class    _snake_case      (  unittest.TestCase       ):
  
  
  
  
  
  
  
  			@slow
  			def     SCREAMING_SNAKE_CASE					(       self	):
  				__magic_name__	:	Dict			     =  ElectraModel.from_pretrained("google/electra-small-discriminator"	)
  				__magic_name__	:	List[Any]			     =  torch.tensor([[0, 345, 232, 328, 740, 140, 1_695, 69, 6_078, 1_588, 2]]	)
  				__magic_name__	:	int			     =  torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]	)
  				__magic_name__	:	str			     =  model(_a		,     attention_mask=_a	)[0]
  				__magic_name__	:	Dict			     =  torch.Size((1, 11, 256)	)
  				self.assertEqual(output.shape		,     _a	)
  				__magic_name__	:	Tuple			     =  torch.tensor(
  				    [[[0.44_71, 0.68_21, -0.32_65], [0.46_27, 0.52_55, -0.36_68], [0.45_32, 0.33_13, -0.43_44]]]	)
  
  				self.assertTrue(torch.allclose(output[:, 1:4, 1:4]		,     _a		,     atol=1e-4	)	)
  
style_context: 
  import os
  from shutil import copyfile
  from typing import List, Optional, Tuple
  
  from ...tokenization_utils import AddedToken
  from ...tokenization_utils_fast import PreTrainedTokenizerFast
  from ...utils import is_sentencepiece_available, logging
  
  
  if is_sentencepiece_available():
  				from .tokenization_xlm_roberta import XLMRobertaTokenizer
  else:
  				snake_case				:	Any							   =						None
  
  
  snake_case				:	Union[str, Any]							   =						logging.get_logger(__name__)
  
  snake_case				:	Any							   =						{"vocab_file": "sentencepiece.bpe.model", "tokenizer_file": "tokenizer.json"}
  
  snake_case				:	Optional[Any]							   =						{
      "vocab_file": {
          "xlm-roberta-base": "https://huggingface.co/xlm-roberta-base/resolve/main/sentencepiece.bpe.model",
          "xlm-roberta-large": "https://huggingface.co/xlm-roberta-large/resolve/main/sentencepiece.bpe.model",
          "xlm-roberta-large-finetuned-conll02-dutch": (
              "https://huggingface.co/xlm-roberta-large-finetuned-conll02-dutch/resolve/main/sentencepiece.bpe.model"
          ),
          "xlm-roberta-large-finetuned-conll02-spanish": (
              "https://huggingface.co/xlm-roberta-large-finetuned-conll02-spanish/resolve/main/sentencepiece.bpe.model"
          ),
          "xlm-roberta-large-finetuned-conll03-english": (
              "https://huggingface.co/xlm-roberta-large-finetuned-conll03-english/resolve/main/sentencepiece.bpe.model"
          ),
          "xlm-roberta-large-finetuned-conll03-german": (
              "https://huggingface.co/xlm-roberta-large-finetuned-conll03-german/resolve/main/sentencepiece.bpe.model"
          ),
      },
      "tokenizer_file": {
          "xlm-roberta-base": "https://huggingface.co/xlm-roberta-base/resolve/main/tokenizer.json",
          "xlm-roberta-large": "https://huggingface.co/xlm-roberta-large/resolve/main/tokenizer.json",
          "xlm-roberta-large-finetuned-conll02-dutch": (
              "https://huggingface.co/xlm-roberta-large-finetuned-conll02-dutch/resolve/main/tokenizer.json"
          ),
          "xlm-roberta-large-finetuned-conll02-spanish": (
              "https://huggingface.co/xlm-roberta-large-finetuned-conll02-spanish/resolve/main/tokenizer.json"
          ),
          "xlm-roberta-large-finetuned-conll03-english": (
              "https://huggingface.co/xlm-roberta-large-finetuned-conll03-english/resolve/main/tokenizer.json"
          ),
          "xlm-roberta-large-finetuned-conll03-german": (
              "https://huggingface.co/xlm-roberta-large-finetuned-conll03-german/resolve/main/tokenizer.json"
          ),
      },
  }
  
  snake_case				:	Optional[int]							   =						{
      "xlm-roberta-base": 512,
      "xlm-roberta-large": 512,
      "xlm-roberta-large-finetuned-conll02-dutch": 512,
      "xlm-roberta-large-finetuned-conll02-spanish": 512,
      "xlm-roberta-large-finetuned-conll03-english": 512,
      "xlm-roberta-large-finetuned-conll03-german": 512,
  }
  
  
  
  
  
  class    _snake_case      (  snake_case       ):
  			UpperCamelCase__					   =					VOCAB_FILES_NAMES
  			UpperCamelCase__					   =					PRETRAINED_VOCAB_FILES_MAP
  			UpperCamelCase__					   =					PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  			UpperCamelCase__					   =					['input_ids', 'attention_mask']
  			UpperCamelCase__					   =					XLMRobertaTokenizer
  
  
  
  
  
  
  
  			def __init__(       self		,     _a=None		,     _a=None		,     _a="<s>"		,     _a="</s>"		,     _a="</s>"		,     _a="<s>"		,     _a="<unk>"		,     _a="<pad>"		,     _a="<mask>"		,     **_a		,     ):
  				# Mask token behave like a normal word, i.e. include the space before it
  				__magic_name__	:	List[str]			     =  AddedToken(_a		,     lstrip=_a		,     rstrip=_a	) if isinstance(_a		,     _a	) else mask_token
  
  				super().__init__(
  				    _a		,     tokenizer_file=_a		,     bos_token=_a		,     eos_token=_a		,     sep_token=_a		,     cls_token=_a		,     unk_token=_a		,     pad_token=_a		,     mask_token=_a		,     **_a		,     )
  
  				__magic_name__	:	Optional[int]			     =  vocab_file
  				__magic_name__	:	List[str]			     =  False if not self.vocab_file else True
  
  
  
  
  
  
  
  			def     SCREAMING_SNAKE_CASE					(       self		,     _a		,     _a = None	):
  
  				if token_ids_a is None:
  					return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
  				__magic_name__	:	Union[str, Any]			     =  [self.cls_token_id]
  				__magic_name__	:	str			     =  [self.sep_token_id]
  				return cls + token_ids_a + sep + sep + token_ids_a + sep
  
  
  
  
  
  
  
  			def     SCREAMING_SNAKE_CASE					(       self		,     _a		,     _a = None	):
  				__magic_name__	:	List[str]			     =  [self.sep_token_id]
  				__magic_name__	:	List[str]			     =  [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]
  
  
  
  
  
  
  
  			def     SCREAMING_SNAKE_CASE					(       self		,     _a		,     _a = None	):
  				if not self.can_save_slow_tokenizer:
  					raise ValueError(
  					    "Your fast tokenizer does not have the necessary information to save the vocabulary for a slow "
  					    "tokenizer."	)
  
  				if not os.path.isdir(_a	):
  					logger.error(f'''Vocabulary path ({save_directory}) should be a directory.'''	)
  					return
  				__magic_name__	:	Any			     =  os.path.join(
  				    _a		,     (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]	)
  
  				if os.path.abspath(self.vocab_file	) != os.path.abspath(_a	):
  					copyfile(self.vocab_file		,     _a	)
  
  				return (out_vocab_file,)
  