
"""simple docstring"""






from __future__ import annotations

import copy
import tempfile
import unittest

from transformers import CONFIG_MAPPING, AutoConfig, BertConfig, GPTaConfig, TaConfig, TapasConfig, is_tf_available
from transformers.testing_utils import (
    DUMMY_UNKNOWN_IDENTIFIER,
    SMALL_MODEL_IDENTIFIER,
    RequestCounter,
    require_tensorflow_probability,
    require_tf,
    slow,
)

from ..bert.test_modeling_bert import BertModelTester


if is_tf_available():
 from transformers import (
     TFAutoModel,
     TFAutoModelForCausalLM,
     TFAutoModelForMaskedLM,
     TFAutoModelForPreTraining,
     TFAutoModelForQuestionAnswering,
     TFAutoModelForSeqaSeqLM,
     TFAutoModelForSequenceClassification,
     TFAutoModelForTableQuestionAnswering,
     TFAutoModelForTokenClassification,
     TFAutoModelWithLMHead,
     TFBertForMaskedLM,
     TFBertForPreTraining,
     TFBertForQuestionAnswering,
     TFBertForSequenceClassification,
     TFBertModel,
     TFFunnelBaseModel,
     TFFunnelModel,
     TFGPTaLMHeadModel,
     TFRobertaForMaskedLM,
     TFTaForConditionalGeneration,
     TFTapasForQuestionAnswering,
 )
 from transformers.models.auto.modeling_tf_auto import (
     TF_MODEL_FOR_CAUSAL_LM_MAPPING,
     TF_MODEL_FOR_MASKED_LM_MAPPING,
     TF_MODEL_FOR_PRETRAINING_MAPPING,
     TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
     TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
     TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
     TF_MODEL_MAPPING,
 )
 from transformers.models.bert.modeling_tf_bert import TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST
 from transformers.models.gpta.modeling_tf_gpta import TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST
 from transformers.models.ta.modeling_tf_ta import TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST
 from transformers.models.tapas.modeling_tf_tapas import TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST





class 				a__					(						A__       ):
     UpperCAmelCase__         =      '''new-model'''


if is_tf_available():





 class 				a__					(						A__       ):
      UpperCAmelCase__         =      NewModelConfig





@require_tf
class 				a__					(						unittest.TestCase       ):



     @slow
     def  lowerCamelCase_						(							self :Any   ):







      '''simple docstring'''



      UpperCamelCase_     :					int   	='bert-base-cased'
      UpperCamelCase_     :					int   	=AutoConfig.from_pretrained(_lowerCamelCase   )
      self.assertIsNotNone(_lowerCamelCase   )
      self.assertIsInstance(_lowerCamelCase      ,  _lowerCamelCase   )

      UpperCamelCase_     :					str   	=TFAutoModel.from_pretrained(_lowerCamelCase   )
      self.assertIsNotNone(_lowerCamelCase   )
      self.assertIsInstance(_lowerCamelCase      ,  _lowerCamelCase   )



     @slow
     def  lowerCamelCase_						(							self :Union[str, Any]   ):







      '''simple docstring'''



      UpperCamelCase_     :					List[str]   	='bert-base-cased'
      UpperCamelCase_     :					Optional[Any]   	=AutoConfig.from_pretrained(_lowerCamelCase   )
      self.assertIsNotNone(_lowerCamelCase   )
      self.assertIsInstance(_lowerCamelCase      ,  _lowerCamelCase   )

      UpperCamelCase_     :					Optional[int]   	=TFAutoModelForPreTraining.from_pretrained(_lowerCamelCase   )
      self.assertIsNotNone(_lowerCamelCase   )
      self.assertIsInstance(_lowerCamelCase      ,  _lowerCamelCase   )



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







      '''simple docstring'''



      for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       UpperCamelCase_     :					int   	=AutoConfig.from_pretrained(_lowerCamelCase   )
       self.assertIsNotNone(_lowerCamelCase   )
       self.assertIsInstance(_lowerCamelCase      ,  _lowerCamelCase   )

       UpperCamelCase_     :					Optional[int]   	=TFAutoModelForCausalLM.from_pretrained(_lowerCamelCase   )
       UpperCamelCase_	,     UpperCamelCase_     :					Dict   	=TFAutoModelForCausalLM.from_pretrained(_lowerCamelCase      ,  output_loading_info=_lowerCamelCase   )
       self.assertIsNotNone(_lowerCamelCase   )
       self.assertIsInstance(_lowerCamelCase      ,  _lowerCamelCase   )



     @slow
     def  lowerCamelCase_						(							self :Optional[int]   ):







      '''simple docstring'''



      for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       UpperCamelCase_     :					Any   	=AutoConfig.from_pretrained(_lowerCamelCase   )
       self.assertIsNotNone(_lowerCamelCase   )
       self.assertIsInstance(_lowerCamelCase      ,  _lowerCamelCase   )

       UpperCamelCase_     :					List[Any]   	=TFAutoModelWithLMHead.from_pretrained(_lowerCamelCase   )
       self.assertIsNotNone(_lowerCamelCase   )
       self.assertIsInstance(_lowerCamelCase      ,  _lowerCamelCase   )



     @slow
     def  lowerCamelCase_						(							self :int   ):







      '''simple docstring'''



      for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       UpperCamelCase_     :					Optional[int]   	=AutoConfig.from_pretrained(_lowerCamelCase   )
       self.assertIsNotNone(_lowerCamelCase   )
       self.assertIsInstance(_lowerCamelCase      ,  _lowerCamelCase   )

       UpperCamelCase_     :					Optional[int]   	=TFAutoModelForMaskedLM.from_pretrained(_lowerCamelCase   )
       UpperCamelCase_	,     UpperCamelCase_     :					int   	=TFAutoModelForMaskedLM.from_pretrained(_lowerCamelCase      ,  output_loading_info=_lowerCamelCase   )
       self.assertIsNotNone(_lowerCamelCase   )
       self.assertIsInstance(_lowerCamelCase      ,  _lowerCamelCase   )



     @slow
     def  lowerCamelCase_						(							self :Tuple   ):







      '''simple docstring'''



      for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       UpperCamelCase_     :					Tuple   	=AutoConfig.from_pretrained(_lowerCamelCase   )
       self.assertIsNotNone(_lowerCamelCase   )
       self.assertIsInstance(_lowerCamelCase      ,  _lowerCamelCase   )

       UpperCamelCase_     :					Optional[int]   	=TFAutoModelForSeqaSeqLM.from_pretrained(_lowerCamelCase   )
       UpperCamelCase_	,     UpperCamelCase_     :					str   	=TFAutoModelForSeqaSeqLM.from_pretrained(_lowerCamelCase      ,  output_loading_info=_lowerCamelCase   )
       self.assertIsNotNone(_lowerCamelCase   )
       self.assertIsInstance(_lowerCamelCase      ,  _lowerCamelCase   )



     @slow
     def  lowerCamelCase_						(							self :Tuple   ):







      '''simple docstring'''



      for model_name in ["bert-base-uncased"]:
       UpperCamelCase_     :					Optional[Any]   	=AutoConfig.from_pretrained(_lowerCamelCase   )
       self.assertIsNotNone(_lowerCamelCase   )
       self.assertIsInstance(_lowerCamelCase      ,  _lowerCamelCase   )

       UpperCamelCase_     :					List[str]   	=TFAutoModelForSequenceClassification.from_pretrained(_lowerCamelCase   )
       self.assertIsNotNone(_lowerCamelCase   )
       self.assertIsInstance(_lowerCamelCase      ,  _lowerCamelCase   )



     @slow
     def  lowerCamelCase_						(							self :Optional[Any]   ):







      '''simple docstring'''



      for model_name in ["bert-base-uncased"]:
       UpperCamelCase_     :					Dict   	=AutoConfig.from_pretrained(_lowerCamelCase   )
       self.assertIsNotNone(_lowerCamelCase   )
       self.assertIsInstance(_lowerCamelCase      ,  _lowerCamelCase   )

       UpperCamelCase_     :					str   	=TFAutoModelForQuestionAnswering.from_pretrained(_lowerCamelCase   )
       self.assertIsNotNone(_lowerCamelCase   )
       self.assertIsInstance(_lowerCamelCase      ,  _lowerCamelCase   )



     @slow
     @require_tensorflow_probability
     def  lowerCamelCase_						(							self :Optional[Any]   ):







      '''simple docstring'''



      for model_name in TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST[5:6]:
       UpperCamelCase_     :					Any   	=AutoConfig.from_pretrained(_lowerCamelCase   )
       self.assertIsNotNone(_lowerCamelCase   )
       self.assertIsInstance(_lowerCamelCase      ,  _lowerCamelCase   )

       UpperCamelCase_     :					List[Any]   	=TFAutoModelForTableQuestionAnswering.from_pretrained(_lowerCamelCase   )
       UpperCamelCase_	,     UpperCamelCase_     :					Optional[int]   	=TFAutoModelForTableQuestionAnswering.from_pretrained(
           _lowerCamelCase      ,  output_loading_info=_lowerCamelCase   )
       self.assertIsNotNone(_lowerCamelCase   )
       self.assertIsInstance(_lowerCamelCase      ,  _lowerCamelCase   )



     def  lowerCamelCase_						(							self :str   ):







      '''simple docstring'''



      UpperCamelCase_     :					List[Any]   	=TFAutoModelWithLMHead.from_pretrained(_lowerCamelCase   )
      self.assertIsInstance(_lowerCamelCase      ,  _lowerCamelCase   )
      self.assertEqual(model.num_parameters()      ,  14_410   )
      self.assertEqual(model.num_parameters(only_trainable=_lowerCamelCase   )      ,  14_410   )



     def  lowerCamelCase_						(							self :Optional[Any]   ):







      '''simple docstring'''



      UpperCamelCase_     :					Union[str, Any]   	=TFAutoModelWithLMHead.from_pretrained(_lowerCamelCase   )
      self.assertIsInstance(_lowerCamelCase      ,  _lowerCamelCase   )
      self.assertEqual(model.num_parameters()      ,  14_410   )
      self.assertEqual(model.num_parameters(only_trainable=_lowerCamelCase   )      ,  14_410   )



     def  lowerCamelCase_						(							self :Optional[Any]   ):







      '''simple docstring'''



      UpperCamelCase_     :					Any   	=TFAutoModel.from_pretrained('sgugger/funnel-random-tiny'   )
      self.assertIsInstance(_lowerCamelCase      ,  _lowerCamelCase   )

      UpperCamelCase_     :					int   	=copy.deepcopy(model.config   )
      UpperCamelCase_     :					List[Any]   	=['FunnelBaseModel']
      UpperCamelCase_     :					Tuple   	=TFAutoModel.from_config(_lowerCamelCase   )
      self.assertIsInstance(_lowerCamelCase      ,  _lowerCamelCase   )

      with tempfile.TemporaryDirectory() as tmp_dir:
       model.save_pretrained(_lowerCamelCase   )
       UpperCamelCase_     :					Tuple   	=TFAutoModel.from_pretrained(_lowerCamelCase   )
       self.assertIsInstance(_lowerCamelCase      ,  _lowerCamelCase   )



     def  lowerCamelCase_						(							self :int   ):







      '''simple docstring'''



      try:
       AutoConfig.register('new-model'      ,  _lowerCamelCase   )

       UpperCamelCase_     :					List[str]   	=[
           TFAutoModel,
           TFAutoModelForCausalLM,
           TFAutoModelForMaskedLM,
           TFAutoModelForPreTraining,
           TFAutoModelForQuestionAnswering,
           TFAutoModelForSequenceClassification,
           TFAutoModelForTokenClassification,
       ]

       for auto_class in auto_classes:
        with self.subTest(auto_class.__name__   ):
         # Wrong config class will raise an error
         with self.assertRaises(_lowerCamelCase   ):
          auto_class.register(_lowerCamelCase      ,  _lowerCamelCase   )
         auto_class.register(_lowerCamelCase      ,  _lowerCamelCase   )
         # Trying to register something existing in the Transformers library will raise an error
         with self.assertRaises(_lowerCamelCase   ):
          auto_class.register(_lowerCamelCase      ,  _lowerCamelCase   )

         # Now that the config is registered, it can be used as any other config with the auto-API
         UpperCamelCase_     :					int   	=BertModelTester(self   ).get_config()
         UpperCamelCase_     :					str   	=NewModelConfig(**tiny_config.to_dict()   )
         UpperCamelCase_     :					int   	=auto_class.from_config(_lowerCamelCase   )
         self.assertIsInstance(_lowerCamelCase      ,  _lowerCamelCase   )

         with tempfile.TemporaryDirectory() as tmp_dir:
          model.save_pretrained(_lowerCamelCase   )
          UpperCamelCase_     :					str   	=auto_class.from_pretrained(_lowerCamelCase   )
          self.assertIsInstance(_lowerCamelCase      ,  _lowerCamelCase   )

      finally:
       if "new-model" in CONFIG_MAPPING._extra_content:
        del CONFIG_MAPPING._extra_content["new-model"]
       for mapping in (
           TF_MODEL_MAPPING,
           TF_MODEL_FOR_PRETRAINING_MAPPING,
           TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
           TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
           TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
           TF_MODEL_FOR_CAUSAL_LM_MAPPING,
           TF_MODEL_FOR_MASKED_LM_MAPPING,
       ):
        if NewModelConfig in mapping._extra_content:
         del mapping._extra_content[NewModelConfig]



     def  lowerCamelCase_						(							self :Dict   ):







      '''simple docstring'''



      with self.assertRaisesRegex(
          _lowerCamelCase      ,  'bert-base is not a local folder and is not a valid model identifier'   ):
       UpperCamelCase_     :					Optional[Any]   	=TFAutoModel.from_pretrained('bert-base'   )



     def  lowerCamelCase_						(							self :List[str]   ):







      '''simple docstring'''



      with self.assertRaisesRegex(
          _lowerCamelCase      ,  r'aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'   ):
       UpperCamelCase_     :					Any   	=TFAutoModel.from_pretrained(_lowerCamelCase      ,  revision='aaaaaa'   )



     def  lowerCamelCase_						(							self :Optional[int]   ):







      '''simple docstring'''



      with self.assertRaisesRegex(
          _lowerCamelCase      ,  'hf-internal-testing/config-no-model does not appear to have a file named pytorch_model.bin'      ,  ):
       UpperCamelCase_     :					Any   	=TFAutoModel.from_pretrained('hf-internal-testing/config-no-model'   )



     def  lowerCamelCase_						(							self :Dict   ):







      '''simple docstring'''



      with self.assertRaisesRegex(_lowerCamelCase      ,  'Use `from_pt=True` to load this model'   ):
       UpperCamelCase_     :					Any   	=TFAutoModel.from_pretrained('hf-internal-testing/tiny-bert-pt-only'   )




     def  lowerCamelCase_						(							self :Optional[int]   ):







      '''simple docstring'''



      UpperCamelCase_     :					int   	=TFAutoModel.from_pretrained('hf-internal-testing/tiny-random-bert'   )
      with RequestCounter() as counter:
       UpperCamelCase_     :					Tuple   	=TFAutoModel.from_pretrained('hf-internal-testing/tiny-random-bert'   )
       self.assertEqual(counter.get_request_count      ,  0   )
       self.assertEqual(counter.head_request_count      ,  1   )
       self.assertEqual(counter.other_request_count      ,  0   )

      # With a sharded checkpoint
      UpperCamelCase_     :					Tuple   	=TFAutoModel.from_pretrained('ArthurZ/tiny-random-bert-sharded'   )
      with RequestCounter() as counter:
       UpperCamelCase_     :					Optional[int]   	=TFAutoModel.from_pretrained('ArthurZ/tiny-random-bert-sharded'   )
       self.assertEqual(counter.get_request_count      ,  0   )
       self.assertEqual(counter.head_request_count      ,  1   )
       self.assertEqual(counter.other_request_count      ,  0   )


"""simple docstring"""






import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_funnel import FunnelTokenizer


__SCREAMING_SNAKE_CASE							=     logging.get_logger(__name__)

__SCREAMING_SNAKE_CASE							=     {'vocab_file': 'vocab.txt', 'tokenizer_file': 'tokenizer.json'}

__SCREAMING_SNAKE_CASE							=     [
    'small',
    'small-base',
    'medium',
    'medium-base',
    'intermediate',
    'intermediate-base',
    'large',
    'large-base',
    'xlarge',
    'xlarge-base',
]

__SCREAMING_SNAKE_CASE							=     {
    'vocab_file': {
        'funnel-transformer/small': 'https://huggingface.co/funnel-transformer/small/resolve/main/vocab.txt',
        'funnel-transformer/small-base': 'https://huggingface.co/funnel-transformer/small-base/resolve/main/vocab.txt',
        'funnel-transformer/medium': 'https://huggingface.co/funnel-transformer/medium/resolve/main/vocab.txt',
        'funnel-transformer/medium-base': (
            'https://huggingface.co/funnel-transformer/medium-base/resolve/main/vocab.txt'
        ),
        'funnel-transformer/intermediate': (
            'https://huggingface.co/funnel-transformer/intermediate/resolve/main/vocab.txt'
        ),
        'funnel-transformer/intermediate-base': (
            'https://huggingface.co/funnel-transformer/intermediate-base/resolve/main/vocab.txt'
        ),
        'funnel-transformer/large': 'https://huggingface.co/funnel-transformer/large/resolve/main/vocab.txt',
        'funnel-transformer/large-base': 'https://huggingface.co/funnel-transformer/large-base/resolve/main/vocab.txt',
        'funnel-transformer/xlarge': 'https://huggingface.co/funnel-transformer/xlarge/resolve/main/vocab.txt',
        'funnel-transformer/xlarge-base': (
            'https://huggingface.co/funnel-transformer/xlarge-base/resolve/main/vocab.txt'
        ),
    },
    'tokenizer_file': {
        'funnel-transformer/small': 'https://huggingface.co/funnel-transformer/small/resolve/main/tokenizer.json',
        'funnel-transformer/small-base': (
            'https://huggingface.co/funnel-transformer/small-base/resolve/main/tokenizer.json'
        ),
        'funnel-transformer/medium': 'https://huggingface.co/funnel-transformer/medium/resolve/main/tokenizer.json',
        'funnel-transformer/medium-base': (
            'https://huggingface.co/funnel-transformer/medium-base/resolve/main/tokenizer.json'
        ),
        'funnel-transformer/intermediate': (
            'https://huggingface.co/funnel-transformer/intermediate/resolve/main/tokenizer.json'
        ),
        'funnel-transformer/intermediate-base': (
            'https://huggingface.co/funnel-transformer/intermediate-base/resolve/main/tokenizer.json'
        ),
        'funnel-transformer/large': 'https://huggingface.co/funnel-transformer/large/resolve/main/tokenizer.json',
        'funnel-transformer/large-base': (
            'https://huggingface.co/funnel-transformer/large-base/resolve/main/tokenizer.json'
        ),
        'funnel-transformer/xlarge': 'https://huggingface.co/funnel-transformer/xlarge/resolve/main/tokenizer.json',
        'funnel-transformer/xlarge-base': (
            'https://huggingface.co/funnel-transformer/xlarge-base/resolve/main/tokenizer.json'
        ),
    },
}
__SCREAMING_SNAKE_CASE							=     {F"""funnel-transformer/{name}""": 512 for name in _model_names}
__SCREAMING_SNAKE_CASE							=     {F"""funnel-transformer/{name}""": {'do_lower_case': True} for name in _model_names}





class 				a__					(						A__       ):
     UpperCAmelCase__         =      VOCAB_FILES_NAMES
     UpperCAmelCase__         =      PRETRAINED_VOCAB_FILES_MAP
     UpperCAmelCase__         =      PRETRAINED_INIT_CONFIGURATION
     UpperCAmelCase__         =      FunnelTokenizer
     UpperCAmelCase__         =      PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
     UpperCAmelCase__         =      2



     def __init__(							self :str      ,  _lowerCamelCase :int=None      ,  _lowerCamelCase :List[Any]=None      ,  _lowerCamelCase :Dict=True      ,  _lowerCamelCase :Optional[Any]="<unk>"      ,  _lowerCamelCase :Optional[Any]="<sep>"      ,  _lowerCamelCase :List[Any]="<pad>"      ,  _lowerCamelCase :List[Any]="<cls>"      ,  _lowerCamelCase :Union[str, Any]="<mask>"      ,  _lowerCamelCase :Any="<s>"      ,  _lowerCamelCase :Union[str, Any]="</s>"      ,  _lowerCamelCase :str=True      ,  _lowerCamelCase :Dict=True      ,  _lowerCamelCase :Tuple=None      ,  _lowerCamelCase :Tuple="##"      ,  **_lowerCamelCase :int      ,  ):







      '''simple docstring'''



      super().__init__(
          _lowerCamelCase      ,  tokenizer_file=_lowerCamelCase      ,  do_lower_case=_lowerCamelCase      ,  unk_token=_lowerCamelCase      ,  sep_token=_lowerCamelCase      ,  pad_token=_lowerCamelCase      ,  cls_token=_lowerCamelCase      ,  mask_token=_lowerCamelCase      ,  bos_token=_lowerCamelCase      ,  eos_token=_lowerCamelCase      ,  clean_text=_lowerCamelCase      ,  tokenize_chinese_chars=_lowerCamelCase      ,  strip_accents=_lowerCamelCase      ,  wordpieces_prefix=_lowerCamelCase      ,  **_lowerCamelCase      ,  )

      UpperCamelCase_     :					str   	=json.loads(self.backend_tokenizer.normalizer.__getstate__()   )
      if (
          normalizer_state.get('lowercase'      ,  _lowerCamelCase   ) != do_lower_case
          or normalizer_state.get('strip_accents'      ,  _lowerCamelCase   ) != strip_accents
          or normalizer_state.get('handle_chinese_chars'      ,  _lowerCamelCase   ) != tokenize_chinese_chars
      ):
       UpperCamelCase_     :					int   	=getattr(_lowerCamelCase      ,  normalizer_state.pop('type'   )   )
       UpperCamelCase_     :					Dict   	=do_lower_case
       UpperCamelCase_     :					Tuple   	=strip_accents
       UpperCamelCase_     :					int   	=tokenize_chinese_chars
       UpperCamelCase_     :					Tuple   	=normalizer_class(**_lowerCamelCase   )

      UpperCamelCase_     :					Dict   	=do_lower_case



     def  lowerCamelCase_						(							self :Optional[int]      ,  _lowerCamelCase :str      ,  _lowerCamelCase :Optional[int]=None   ):







      '''simple docstring'''



      UpperCamelCase_     :					Optional[Any]   	=[self.cls_token_id] + token_ids_a + [self.sep_token_id]

      if token_ids_a:
       output += token_ids_a + [self.sep_token_id]

      return output



     def  lowerCamelCase_						(							self :List[Any]      ,  _lowerCamelCase :List[int]      ,  _lowerCamelCase :Optional[List[int]] = None   ):







      '''simple docstring'''



      UpperCamelCase_     :					Optional[int]   	=[self.sep_token_id]
      UpperCamelCase_     :					List[Any]   	=[self.cls_token_id]
      if token_ids_a is None:
       return len(cls   ) * [self.cls_token_type_id] + len(token_ids_a + sep   ) * [0]
      return len(cls   ) * [self.cls_token_type_id] + len(token_ids_a + sep   ) * [0] + len(token_ids_a + sep   ) * [1]




     def  lowerCamelCase_						(							self :Optional[Any]      ,  _lowerCamelCase :str      ,  _lowerCamelCase :Optional[str] = None   ):







      '''simple docstring'''



      UpperCamelCase_     :					int   	=self._tokenizer.model.save(_lowerCamelCase      ,  name=_lowerCamelCase   )
      return tuple(_lowerCamelCase   )
