





import os
import shutil
import sys
import tempfile
import unittest
from pathlib import Path

import pytest

import transformers
from transformers import (
    BERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP,
    AutoTokenizer,
    BertConfig,
    BertTokenizer,
    BertTokenizerFast,
    CTRLTokenizer,
    GPTaTokenizer,
    GPTaTokenizerFast,
    PreTrainedTokenizerFast,
    RobertaTokenizer,
    RobertaTokenizerFast,
    is_tokenizers_available,
)
from transformers.models.auto.configuration_auto import CONFIG_MAPPING, AutoConfig
from transformers.models.auto.tokenization_auto import (
    TOKENIZER_MAPPING,
    get_tokenizer_config,
    tokenizer_class_from_name,
)
from transformers.models.roberta.configuration_roberta import RobertaConfig
from transformers.testing_utils import (
    DUMMY_DIFF_TOKENIZER_IDENTIFIER,
    DUMMY_UNKNOWN_IDENTIFIER,
    SMALL_MODEL_IDENTIFIER,
    RequestCounter,
    require_tokenizers,
    slow,
)


sys.path.append(str(Path(__file__).parent.parent.parent.parent / 'utils'))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_tokenization import CustomTokenizer  # noqa E402


if is_tokenizers_available():
       from test_module.custom_tokenization_fast import CustomTokenizerFast


class    __SCREAMING_SNAKE_CASE			( unittest.TestCase					):







       def 						__lowerCamelCase    (      self     :	int			)   ->Tuple:
          lowerCamelCase__   :						str					   =							0







       @slow
       def 						__lowerCamelCase    (      self     :	Union[str, Any]			)   ->Tuple:
          for model_name in (x for x in BERT_PRETRAINED_CONFIG_ARCHIVE_MAP.keys() if "japanese" not in x):
             lowerCamelCase__   :						Tuple					   =							AutoTokenizer.from_pretrained(_a			)
             self.assertIsNotNone(_a			)
             self.assertIsInstance(_a		,					(BertTokenizer, BertTokenizerFast)			)
             self.assertGreater(len(_a			)		,					0			)

          for model_name in GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP.keys():
             lowerCamelCase__   :						Optional[Any]					   =							AutoTokenizer.from_pretrained(_a			)
             self.assertIsNotNone(_a			)
             self.assertIsInstance(_a		,					(GPTaTokenizer, GPTaTokenizerFast)			)
             self.assertGreater(len(_a			)		,					0			)







       def 						__lowerCamelCase    (      self     :	List[str]			)   ->List[str]:
          lowerCamelCase__   :						str					   =							AutoTokenizer.from_pretrained(_a			)
          self.assertIsInstance(_a		,					(BertTokenizer, BertTokenizerFast)			)
          self.assertEqual(tokenizer.vocab_size		,					1_2			)







       def 						__lowerCamelCase    (      self     :	int			)   ->Tuple:
          lowerCamelCase__   :						str					   =							AutoTokenizer.from_pretrained(_a			)
          self.assertIsInstance(_a		,					(RobertaTokenizer, RobertaTokenizerFast)			)
          self.assertEqual(tokenizer.vocab_size		,					2_0			)







       def 						__lowerCamelCase    (      self     :	Tuple			)   ->str:
          lowerCamelCase__   :						int					   =							AutoConfig.from_pretrained(_a			)
          self.assertIsInstance(_a		,					_a			)
          # Check that tokenizer_type ≠ model_type
          lowerCamelCase__   :						int					   =							AutoTokenizer.from_pretrained(_a		,					config=_a			)
          self.assertIsInstance(_a		,					(BertTokenizer, BertTokenizerFast)			)
          self.assertEqual(tokenizer.vocab_size		,					1_2			)







       def 						__lowerCamelCase    (      self     :	List[Any]			)   ->Dict:
          with tempfile.TemporaryDirectory() as tmp_dir:
             shutil.copy('''./tests/fixtures/vocab.txt'''		,					os.path.join(_a		,					'''vocab.txt'''			)			)

             lowerCamelCase__   :						Dict					   =							AutoTokenizer.from_pretrained(_a		,					tokenizer_type='''bert'''		,					use_fast=_a			)
             self.assertIsInstance(_a		,					_a			)

          with tempfile.TemporaryDirectory() as tmp_dir:
             shutil.copy('''./tests/fixtures/vocab.json'''		,					os.path.join(_a		,					'''vocab.json'''			)			)
             shutil.copy('''./tests/fixtures/merges.txt'''		,					os.path.join(_a		,					'''merges.txt'''			)			)

             lowerCamelCase__   :						str					   =							AutoTokenizer.from_pretrained(_a		,					tokenizer_type='''gpt2'''		,					use_fast=_a			)
             self.assertIsInstance(_a		,					_a			)







       @require_tokenizers
       def 						__lowerCamelCase    (      self     :	Any			)   ->Union[str, Any]:
          with tempfile.TemporaryDirectory() as tmp_dir:
             shutil.copy('''./tests/fixtures/vocab.txt'''		,					os.path.join(_a		,					'''vocab.txt'''			)			)

             lowerCamelCase__   :						int					   =							AutoTokenizer.from_pretrained(_a		,					tokenizer_type='''bert'''			)
             self.assertIsInstance(_a		,					_a			)

          with tempfile.TemporaryDirectory() as tmp_dir:
             shutil.copy('''./tests/fixtures/vocab.json'''		,					os.path.join(_a		,					'''vocab.json'''			)			)
             shutil.copy('''./tests/fixtures/merges.txt'''		,					os.path.join(_a		,					'''merges.txt'''			)			)

             lowerCamelCase__   :						Dict					   =							AutoTokenizer.from_pretrained(_a		,					tokenizer_type='''gpt2'''			)
             self.assertIsInstance(_a		,					_a			)







       def 						__lowerCamelCase    (      self     :	List[Any]			)   ->Tuple:
          with pytest.raises(_a			):
             AutoTokenizer.from_pretrained('''./'''		,					tokenizer_type='''xxx'''			)







       @require_tokenizers
       def 						__lowerCamelCase    (      self     :	int			)   ->List[str]:
          for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
             lowerCamelCase__   :						List[str]					   =							tokenizer_class.from_pretrained('''wietsedv/bert-base-dutch-cased'''			)
             self.assertIsInstance(_a		,					(BertTokenizer, BertTokenizerFast)			)

             if isinstance(_a		,					_a			):
                self.assertEqual(tokenizer.basic_tokenizer.do_lower_case		,					_a			)
             else:
                self.assertEqual(tokenizer.do_lower_case		,					_a			)

             self.assertEqual(tokenizer.model_max_length		,					5_1_2			)







       @require_tokenizers
       def 						__lowerCamelCase    (      self     :	Any			)   ->Union[str, Any]:
          for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
             with self.assertRaisesRegex(
                 _a		,					'''julien-c/herlolip-not-exists is not a local folder and is not a valid model identifier'''		,					):
                lowerCamelCase__   :						Dict					   =							tokenizer_class.from_pretrained('''julien-c/herlolip-not-exists'''			)







       def 						__lowerCamelCase    (      self     :	Any			)   ->int:
          # tests: https://github.com/huggingface/transformers/pull/13251
          # 1. models with `-`, e.g. xlm-roberta -> xlm_roberta
          # 2. models that don't remap 1-1 from model-name to model file, e.g., openai-gpt -> openai
          lowerCamelCase__   :						Dict					   =							TOKENIZER_MAPPING.values()
          lowerCamelCase__   :						Optional[Any]					   =							[]

          for slow_tok, fast_tok in tokenizers:
             if slow_tok is not None:
                tokenizer_names.append(slow_tok.__name__			)

             if fast_tok is not None:
                tokenizer_names.append(fast_tok.__name__			)

          for tokenizer_name in tokenizer_names:
             # must find the right class
             tokenizer_class_from_name(_a			)







       @require_tokenizers
       def 						__lowerCamelCase    (      self     :	Optional[Any]			)   ->str:
          self.assertIsInstance(AutoTokenizer.from_pretrained('''bert-base-cased'''		,					use_fast=_a			)		,					_a			)
          self.assertIsInstance(AutoTokenizer.from_pretrained('''bert-base-cased'''			)		,					_a			)







       @require_tokenizers
       def 						__lowerCamelCase    (      self     :	Union[str, Any]			)   ->Union[str, Any]:
          lowerCamelCase__   :						Optional[Any]					   =							AutoTokenizer.from_pretrained('''distilbert-base-uncased'''		,					do_lower_case=_a			)
          lowerCamelCase__   :						Optional[Any]					   =							"""Hello, world. How are you?"""
          lowerCamelCase__   :						List[Any]					   =							tokenizer.tokenize(_a			)
          self.assertEqual('''[UNK]'''		,					tokens[0]			)

          lowerCamelCase__   :						str					   =							AutoTokenizer.from_pretrained('''microsoft/mpnet-base'''		,					do_lower_case=_a			)
          lowerCamelCase__   :						Tuple					   =							tokenizer.tokenize(_a			)
          self.assertEqual('''[UNK]'''		,					tokens[0]			)







       @require_tokenizers
       def 						__lowerCamelCase    (      self     :	Dict			)   ->Any:
          lowerCamelCase__   :						Optional[int]					   =							AutoTokenizer.from_pretrained('''robot-test/dummy-tokenizer-fast-with-model-config'''			)
          self.assertEqual(type(_a			)		,					_a			)
          self.assertEqual(tokenizer.model_max_length		,					5_1_2			)
          self.assertEqual(tokenizer.vocab_size		,					3_0_0_0_0			)
          self.assertEqual(tokenizer.unk_token		,					'''[UNK]'''			)
          self.assertEqual(tokenizer.padding_side		,					'''right'''			)
          self.assertEqual(tokenizer.truncation_side		,					'''right'''			)







       def 						__lowerCamelCase    (      self     :	Optional[Any]			)   ->Tuple:
          lowerCamelCase__   :						Optional[int]					   =							AutoTokenizer.from_pretrained(_a			)
          self.assertIsInstance(_a		,					(BertTokenizer, BertTokenizerFast)			)
          with tempfile.TemporaryDirectory() as tmp_dir:
             tokenizer.save_pretrained(_a			)
             lowerCamelCase__   :						List[str]					   =							AutoTokenizer.from_pretrained(_a			)

          self.assertIsInstance(_a		,					tokenizer.__class__			)
          self.assertEqual(tokenizera.vocab_size		,					1_2			)







       def 						__lowerCamelCase    (      self     :	str			)   ->Dict:
          lowerCamelCase__   :						Tuple					   =							AutoTokenizer.from_pretrained('''ctrl'''			)
          # There is no fast CTRL so this always gives us a slow tokenizer.
          self.assertIsInstance(_a		,					_a			)







       def 						__lowerCamelCase    (      self     :	List[Any]			)   ->Union[str, Any]:
          # Check we can load the tokenizer config of an online model.
          lowerCamelCase__   :						List[str]					   =							get_tokenizer_config('''bert-base-cased'''			)
          lowerCamelCase__   :						Any					   =							config.pop('''_commit_hash'''		,					_a			)
          # If we ever update bert-base-cased tokenizer config, this dict here will need to be updated.
          self.assertEqual(_a		,					{'''do_lower_case''': False}			)

          # This model does not have a tokenizer_config so we get back an empty dict.
          lowerCamelCase__   :						Optional[int]					   =							get_tokenizer_config(_a			)
          self.assertDictEqual(_a		,					{}			)

          # A tokenizer saved with `save_pretrained` always creates a tokenizer config.
          lowerCamelCase__   :						Union[str, Any]					   =							AutoTokenizer.from_pretrained(_a			)
          with tempfile.TemporaryDirectory() as tmp_dir:
             tokenizer.save_pretrained(_a			)
             lowerCamelCase__   :						List[Any]					   =							get_tokenizer_config(_a			)

          # Check the class of the tokenizer was properly saved (note that it always saves the slow class).
          self.assertEqual(config['''tokenizer_class''']		,					'''BertTokenizer'''			)







       def 						__lowerCamelCase    (      self     :	Union[str, Any]			)   ->Optional[int]:
          try:
             AutoConfig.register('''custom'''		,					_a			)

             AutoTokenizer.register(_a		,					slow_tokenizer_class=_a			)
             # Trying to register something existing in the Transformers library will raise an error
             with self.assertRaises(_a			):
                AutoTokenizer.register(_a		,					slow_tokenizer_class=_a			)

             lowerCamelCase__   :						List[Any]					   =							CustomTokenizer.from_pretrained(_a			)
             with tempfile.TemporaryDirectory() as tmp_dir:
                tokenizer.save_pretrained(_a			)

                lowerCamelCase__   :						int					   =							AutoTokenizer.from_pretrained(_a			)
                self.assertIsInstance(_a		,					_a			)

          finally:
             if "custom" in CONFIG_MAPPING._extra_content:
                del CONFIG_MAPPING._extra_content["custom"]
             if CustomConfig in TOKENIZER_MAPPING._extra_content:
                del TOKENIZER_MAPPING._extra_content[CustomConfig]







       @require_tokenizers
       def 						__lowerCamelCase    (      self     :	str			)   ->str:
          try:
             AutoConfig.register('''custom'''		,					_a			)

             # Can register in two steps
             AutoTokenizer.register(_a		,					slow_tokenizer_class=_a			)
             self.assertEqual(TOKENIZER_MAPPING[CustomConfig]		,					(CustomTokenizer, None)			)
             AutoTokenizer.register(_a		,					fast_tokenizer_class=_a			)
             self.assertEqual(TOKENIZER_MAPPING[CustomConfig]		,					(CustomTokenizer, CustomTokenizerFast)			)

             del TOKENIZER_MAPPING._extra_content[CustomConfig]
             # Can register in one step
             AutoTokenizer.register(
                 _a		,					slow_tokenizer_class=_a		,					fast_tokenizer_class=_a			)
             self.assertEqual(TOKENIZER_MAPPING[CustomConfig]		,					(CustomTokenizer, CustomTokenizerFast)			)

             # Trying to register something existing in the Transformers library will raise an error
             with self.assertRaises(_a			):
                AutoTokenizer.register(_a		,					fast_tokenizer_class=_a			)

             # We pass through a bert tokenizer fast cause there is no converter slow to fast for our new toknizer
             # and that model does not have a tokenizer.json
             with tempfile.TemporaryDirectory() as tmp_dir:
                lowerCamelCase__   :						str					   =							BertTokenizerFast.from_pretrained(_a			)
                bert_tokenizer.save_pretrained(_a			)
                lowerCamelCase__   :						Optional[Any]					   =							CustomTokenizerFast.from_pretrained(_a			)

             with tempfile.TemporaryDirectory() as tmp_dir:
                tokenizer.save_pretrained(_a			)

                lowerCamelCase__   :						Any					   =							AutoTokenizer.from_pretrained(_a			)
                self.assertIsInstance(_a		,					_a			)

                lowerCamelCase__   :						Dict					   =							AutoTokenizer.from_pretrained(_a		,					use_fast=_a			)
                self.assertIsInstance(_a		,					_a			)

          finally:
             if "custom" in CONFIG_MAPPING._extra_content:
                del CONFIG_MAPPING._extra_content["custom"]
             if CustomConfig in TOKENIZER_MAPPING._extra_content:
                del TOKENIZER_MAPPING._extra_content[CustomConfig]







       def 						__lowerCamelCase    (      self     :	str			)   ->List[str]:
          # If remote code is not set, we will time out when asking whether to load the model.
          with self.assertRaises(_a			):
             lowerCamelCase__   :						List[Any]					   =							AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer'''			)
          # If remote code is disabled, we can't load this config.
          with self.assertRaises(_a			):
             lowerCamelCase__   :						int					   =							AutoTokenizer.from_pretrained(
                 '''hf-internal-testing/test_dynamic_tokenizer'''		,					trust_remote_code=_a			)

          lowerCamelCase__   :						Dict					   =							AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer'''		,					trust_remote_code=_a			)
          self.assertTrue(tokenizer.special_attribute_present			)
          # Test tokenizer can be reloaded.
          with tempfile.TemporaryDirectory() as tmp_dir:
             tokenizer.save_pretrained(_a			)
             lowerCamelCase__   :						int					   =							AutoTokenizer.from_pretrained(_a		,					trust_remote_code=_a			)
          self.assertTrue(reloaded_tokenizer.special_attribute_present			)

          if is_tokenizers_available():
             self.assertEqual(tokenizer.__class__.__name__		,					'''NewTokenizerFast'''			)
             self.assertEqual(reloaded_tokenizer.__class__.__name__		,					'''NewTokenizerFast'''			)

             # Test we can also load the slow version
             lowerCamelCase__   :						str					   =							AutoTokenizer.from_pretrained(
                 '''hf-internal-testing/test_dynamic_tokenizer'''		,					trust_remote_code=_a		,					use_fast=_a			)
             self.assertTrue(tokenizer.special_attribute_present			)
             self.assertEqual(tokenizer.__class__.__name__		,					'''NewTokenizer'''			)
             # Test tokenizer can be reloaded.
             with tempfile.TemporaryDirectory() as tmp_dir:
                tokenizer.save_pretrained(_a			)
                lowerCamelCase__   :						List[Any]					   =							AutoTokenizer.from_pretrained(_a		,					trust_remote_code=_a		,					use_fast=_a			)
             self.assertEqual(reloaded_tokenizer.__class__.__name__		,					'''NewTokenizer'''			)
             self.assertTrue(reloaded_tokenizer.special_attribute_present			)
          else:
             self.assertEqual(tokenizer.__class__.__name__		,					'''NewTokenizer'''			)
             self.assertEqual(reloaded_tokenizer.__class__.__name__		,					'''NewTokenizer'''			)







       @require_tokenizers
       def 						__lowerCamelCase    (      self     :	List[str]			)   ->int:


          class    __SCREAMING_SNAKE_CASE			( UpperCamelCase__					):
                 _UpperCAmelCase      :  List[Any]     =    False


          class    __SCREAMING_SNAKE_CASE			( UpperCamelCase__					):
                 _UpperCAmelCase      :  Any     =    NewTokenizer
                 _UpperCAmelCase      :  List[str]     =    False

          try:
             AutoConfig.register('''custom'''		,					_a			)
             AutoTokenizer.register(_a		,					slow_tokenizer_class=_a			)
             AutoTokenizer.register(_a		,					fast_tokenizer_class=_a			)
             # If remote code is not set, the default is to use local
             lowerCamelCase__   :						int					   =							AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer'''			)
             self.assertEqual(tokenizer.__class__.__name__		,					'''NewTokenizerFast'''			)
             self.assertFalse(tokenizer.special_attribute_present			)
             lowerCamelCase__   :						Optional[Any]					   =							AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer'''		,					use_fast=_a			)
             self.assertEqual(tokenizer.__class__.__name__		,					'''NewTokenizer'''			)
             self.assertFalse(tokenizer.special_attribute_present			)

             # If remote code is disabled, we load the local one.
             lowerCamelCase__   :						Union[str, Any]					   =							AutoTokenizer.from_pretrained(
                 '''hf-internal-testing/test_dynamic_tokenizer'''		,					trust_remote_code=_a			)
             self.assertEqual(tokenizer.__class__.__name__		,					'''NewTokenizerFast'''			)
             self.assertFalse(tokenizer.special_attribute_present			)
             lowerCamelCase__   :						Union[str, Any]					   =							AutoTokenizer.from_pretrained(
                 '''hf-internal-testing/test_dynamic_tokenizer'''		,					trust_remote_code=_a		,					use_fast=_a			)
             self.assertEqual(tokenizer.__class__.__name__		,					'''NewTokenizer'''			)
             self.assertFalse(tokenizer.special_attribute_present			)

             # If remote is enabled, we load from the Hub
             lowerCamelCase__   :						str					   =							AutoTokenizer.from_pretrained(
                 '''hf-internal-testing/test_dynamic_tokenizer'''		,					trust_remote_code=_a			)
             self.assertEqual(tokenizer.__class__.__name__		,					'''NewTokenizerFast'''			)
             self.assertTrue(tokenizer.special_attribute_present			)
             lowerCamelCase__   :						List[Any]					   =							AutoTokenizer.from_pretrained(
                 '''hf-internal-testing/test_dynamic_tokenizer'''		,					trust_remote_code=_a		,					use_fast=_a			)
             self.assertEqual(tokenizer.__class__.__name__		,					'''NewTokenizer'''			)
             self.assertTrue(tokenizer.special_attribute_present			)

          finally:
             if "custom" in CONFIG_MAPPING._extra_content:
                del CONFIG_MAPPING._extra_content["custom"]
             if CustomConfig in TOKENIZER_MAPPING._extra_content:
                del TOKENIZER_MAPPING._extra_content[CustomConfig]







       def 						__lowerCamelCase    (      self     :	str			)   ->List[Any]:
          lowerCamelCase__   :						List[Any]					   =							AutoTokenizer.from_pretrained(
              '''hf-internal-testing/test_dynamic_tokenizer_legacy'''		,					trust_remote_code=_a			)
          self.assertTrue(tokenizer.special_attribute_present			)
          if is_tokenizers_available():
             self.assertEqual(tokenizer.__class__.__name__		,					'''NewTokenizerFast'''			)

             # Test we can also load the slow version
             lowerCamelCase__   :						str					   =							AutoTokenizer.from_pretrained(
                 '''hf-internal-testing/test_dynamic_tokenizer_legacy'''		,					trust_remote_code=_a		,					use_fast=_a			)
             self.assertTrue(tokenizer.special_attribute_present			)
             self.assertEqual(tokenizer.__class__.__name__		,					'''NewTokenizer'''			)
          else:
             self.assertEqual(tokenizer.__class__.__name__		,					'''NewTokenizer'''			)







       def 						__lowerCamelCase    (      self     :	Dict			)   ->Tuple:
          with self.assertRaisesRegex(
              _a		,					'''bert-base is not a local folder and is not a valid model identifier'''			):
             lowerCamelCase__   :						List[str]					   =							AutoTokenizer.from_pretrained('''bert-base'''			)







       def 						__lowerCamelCase    (      self     :	List[str]			)   ->str:
          with self.assertRaisesRegex(
              _a		,					R'''aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'''			):
             lowerCamelCase__   :						Union[str, Any]					   =							AutoTokenizer.from_pretrained(_a		,					revision='''aaaaaa'''			)







       def 						__lowerCamelCase    (      self     :	int			)   ->str:
          # Make sure we have cached the tokenizer.
          lowerCamelCase__   :						Any					   =							AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bert'''			)
          with RequestCounter() as counter:
             lowerCamelCase__   :						Optional[int]					   =							AutoTokenizer.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			)









from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


_snake_case										=       logging.get_logger(__name__)

_snake_case										=       {
    "facebook/xmod-base": "https://huggingface.co/facebook/xmod-base/resolve/main/config.json",
    "facebook/xmod-large-prenorm": "https://huggingface.co/facebook/xmod-large-prenorm/resolve/main/config.json",
    "facebook/xmod-base-13-125k": "https://huggingface.co/facebook/xmod-base-13-125k/resolve/main/config.json",
    "facebook/xmod-base-30-125k": "https://huggingface.co/facebook/xmod-base-30-125k/resolve/main/config.json",
    "facebook/xmod-base-30-195k": "https://huggingface.co/facebook/xmod-base-30-195k/resolve/main/config.json",
    "facebook/xmod-base-60-125k": "https://huggingface.co/facebook/xmod-base-60-125k/resolve/main/config.json",
    "facebook/xmod-base-60-265k": "https://huggingface.co/facebook/xmod-base-60-265k/resolve/main/config.json",
    "facebook/xmod-base-75-125k": "https://huggingface.co/facebook/xmod-base-75-125k/resolve/main/config.json",
    "facebook/xmod-base-75-269k": "https://huggingface.co/facebook/xmod-base-75-269k/resolve/main/config.json",
}







class 						lowercase							(   UpperCamelCase__		):
     _a							 =						"xmod"

     def __init__(  self		,     _a=3_0522		,     _a=768		,     _a=12		,     _a=12		,     _a=3072		,     _a="gelu"		,     _a=0.1		,     _a=0.1		,     _a=512		,     _a=2		,     _a=0.02		,     _a=1e-12		,     _a=1		,     _a=0		,     _a=2		,     _a="absolute"		,     _a=True		,     _a=None		,     _a=False		,     _a=2		,     _a=False		,     _a=True		,     _a=True		,     _a=("en_XX",)		,     _a=None		,     **_a		,     )						->							str:
           super().__init__(pad_token_id=_a		,     bos_token_id=_a		,     eos_token_id=_a		,     **_a				)

           _A							:     Tuple			=						vocab_size
           _A							:     Union[str, Any]			=						hidden_size
           _A							:     Dict			=						num_hidden_layers
           _A							:     Dict			=						num_attention_heads
           _A							:     List[Any]			=						hidden_act
           _A							:     Optional[Any]			=						intermediate_size
           _A							:     Any			=						hidden_dropout_prob
           _A							:     str			=						attention_probs_dropout_prob
           _A							:     Dict			=						max_position_embeddings
           _A							:     Any			=						type_vocab_size
           _A							:     List[Any]			=						initializer_range
           _A							:     int			=						layer_norm_eps
           _A							:     int			=						position_embedding_type
           _A							:     Any			=						use_cache
           _A							:     int			=						classifier_dropout
           _A							:     int			=						pre_norm
           _A							:     Optional[Any]			=						adapter_reduction_factor
           _A							:     List[Any]			=						adapter_layer_norm
           _A							:     Optional[int]			=						adapter_reuse_layer_norm
           _A							:     Any			=						ln_before_adapter
           _A							:     Union[str, Any]			=						list(_a				)
           _A							:     List[Any]			=						default_language







class 						lowercase							(   UpperCamelCase__		):

     @property
     def 					a__	(  self				)						->							Mapping[str, Mapping[int, str]]:
           if self.task == "multiple-choice":
                 _A							:     Dict			=						{0: """batch""", 1: """choice""", 2: """sequence"""}
           else:
                 _A							:     Dict			=						{0: """batch""", 1: """sequence"""}
           return OrderedDict(
               [
                   ("""input_ids""", dynamic_axis),
                   ("""attention_mask""", dynamic_axis),
               ]				)

