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 			lowerCamelCase_  (     unittest.TestCase				):






    '''simple docstring'''






    def     UpperCamelCase__     (			self) ->			Union[str, Any]:
        __UpperCamelCase  :List[str]    						=	0







    @slow
    def     UpperCamelCase__     (			self) ->			Dict:
        for model_name in (x for x in BERT_PRETRAINED_CONFIG_ARCHIVE_MAP.keys() if "japanese" not in x):
            __UpperCamelCase  :Optional[Any]    						=	AutoTokenizer.from_pretrained(__lowercase)
            self.assertIsNotNone(__lowercase)
            self.assertIsInstance(__lowercase				,				(BertTokenizer, BertTokenizerFast))
            self.assertGreater(len(__lowercase)				,				0)

        for model_name in GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP.keys():
            __UpperCamelCase  :List[str]    						=	AutoTokenizer.from_pretrained(__lowercase)
            self.assertIsNotNone(__lowercase)
            self.assertIsInstance(__lowercase				,				(GPTaTokenizer, GPTaTokenizerFast))
            self.assertGreater(len(__lowercase)				,				0)







    def     UpperCamelCase__     (			self) ->			Dict:
        __UpperCamelCase  :Dict    						=	AutoTokenizer.from_pretrained(__lowercase)
        self.assertIsInstance(__lowercase				,				(BertTokenizer, BertTokenizerFast))
        self.assertEqual(tokenizer.vocab_size				,				12)







    def     UpperCamelCase__     (			self) ->			Dict:
        __UpperCamelCase  :Tuple    						=	AutoTokenizer.from_pretrained(__lowercase)
        self.assertIsInstance(__lowercase				,				(RobertaTokenizer, RobertaTokenizerFast))
        self.assertEqual(tokenizer.vocab_size				,				20)







    def     UpperCamelCase__     (			self) ->			Optional[int]:
        __UpperCamelCase  :List[str]    						=	AutoConfig.from_pretrained(__lowercase)
        self.assertIsInstance(__lowercase				,				__lowercase)
        # Check that tokenizer_type ≠ model_type
        __UpperCamelCase  :List[str]    						=	AutoTokenizer.from_pretrained(__lowercase				,				config=__lowercase)
        self.assertIsInstance(__lowercase				,				(BertTokenizer, BertTokenizerFast))
        self.assertEqual(tokenizer.vocab_size				,				12)







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

            __UpperCamelCase  :Any    						=	AutoTokenizer.from_pretrained(__lowercase				,				tokenizer_type='''bert'''				,				use_fast=__lowercase)
            self.assertIsInstance(__lowercase				,				__lowercase)

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

            __UpperCamelCase  :Dict    						=	AutoTokenizer.from_pretrained(__lowercase				,				tokenizer_type='''gpt2'''				,				use_fast=__lowercase)
            self.assertIsInstance(__lowercase				,				__lowercase)







    @require_tokenizers
    def     UpperCamelCase__     (			self) ->			str:
        with tempfile.TemporaryDirectory() as tmp_dir:
            shutil.copy('''./tests/fixtures/vocab.txt'''				,				os.path.join(__lowercase				,				'''vocab.txt'''))

            __UpperCamelCase  :List[str]    						=	AutoTokenizer.from_pretrained(__lowercase				,				tokenizer_type='''bert''')
            self.assertIsInstance(__lowercase				,				__lowercase)

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

            __UpperCamelCase  :List[str]    						=	AutoTokenizer.from_pretrained(__lowercase				,				tokenizer_type='''gpt2''')
            self.assertIsInstance(__lowercase				,				__lowercase)







    def     UpperCamelCase__     (			self) ->			Dict:
        with pytest.raises(__lowercase):
            AutoTokenizer.from_pretrained('''./'''				,				tokenizer_type='''xxx''')







    @require_tokenizers
    def     UpperCamelCase__     (			self) ->			Optional[int]:
        for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
            __UpperCamelCase  :Optional[Any]    						=	tokenizer_class.from_pretrained('''wietsedv/bert-base-dutch-cased''')
            self.assertIsInstance(__lowercase				,				(BertTokenizer, BertTokenizerFast))

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

            self.assertEqual(tokenizer.model_max_length				,				512)







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







    def     UpperCamelCase__     (			self) ->			Optional[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
        __UpperCamelCase  :List[str]    						=	TOKENIZER_MAPPING.values()
        __UpperCamelCase  :int    						=	[]

        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(__lowercase)







    @require_tokenizers
    def     UpperCamelCase__     (			self) ->			Optional[int]:
        self.assertIsInstance(AutoTokenizer.from_pretrained('''bert-base-cased'''				,				use_fast=__lowercase)				,				__lowercase)
        self.assertIsInstance(AutoTokenizer.from_pretrained('''bert-base-cased''')				,				__lowercase)







    @require_tokenizers
    def     UpperCamelCase__     (			self) ->			Optional[int]:
        __UpperCamelCase  :str    						=	AutoTokenizer.from_pretrained('''distilbert-base-uncased'''				,				do_lower_case=__lowercase)
        __UpperCamelCase  :Dict    						=	'''Hello, world. How are you?'''
        __UpperCamelCase  :Any    						=	tokenizer.tokenize(__lowercase)
        self.assertEqual('''[UNK]'''				,				tokens[0])

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







    @require_tokenizers
    def     UpperCamelCase__     (			self) ->			Optional[int]:
        __UpperCamelCase  :Tuple    						=	AutoTokenizer.from_pretrained('''robot-test/dummy-tokenizer-fast-with-model-config''')
        self.assertEqual(type(__lowercase)				,				__lowercase)
        self.assertEqual(tokenizer.model_max_length				,				512)
        self.assertEqual(tokenizer.vocab_size				,				30_000)
        self.assertEqual(tokenizer.unk_token				,				'''[UNK]''')
        self.assertEqual(tokenizer.padding_side				,				'''right''')
        self.assertEqual(tokenizer.truncation_side				,				'''right''')







    def     UpperCamelCase__     (			self) ->			Union[str, Any]:
        __UpperCamelCase  :Dict    						=	AutoTokenizer.from_pretrained(__lowercase)
        self.assertIsInstance(__lowercase				,				(BertTokenizer, BertTokenizerFast))
        with tempfile.TemporaryDirectory() as tmp_dir:
            tokenizer.save_pretrained(__lowercase)
            __UpperCamelCase  :Dict    						=	AutoTokenizer.from_pretrained(__lowercase)

        self.assertIsInstance(__lowercase				,				tokenizer.__class__)
        self.assertEqual(tokenizera.vocab_size				,				12)







    def     UpperCamelCase__     (			self) ->			Union[str, Any]:
        __UpperCamelCase  :Tuple    						=	AutoTokenizer.from_pretrained('''ctrl''')
        # There is no fast CTRL so this always gives us a slow tokenizer.
        self.assertIsInstance(__lowercase				,				__lowercase)







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

        # This model does not have a tokenizer_config so we get back an empty dict.
        __UpperCamelCase  :int    						=	get_tokenizer_config(__lowercase)
        self.assertDictEqual(__lowercase				,				{})

        # A tokenizer saved with `save_pretrained` always creates a tokenizer config.
        __UpperCamelCase  :str    						=	AutoTokenizer.from_pretrained(__lowercase)
        with tempfile.TemporaryDirectory() as tmp_dir:
            tokenizer.save_pretrained(__lowercase)
            __UpperCamelCase  :Optional[Any]    						=	get_tokenizer_config(__lowercase)

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







    def     UpperCamelCase__     (			self) ->			List[str]:
        try:
            AutoConfig.register('''custom'''				,				__lowercase)

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

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

                __UpperCamelCase  :Union[str, Any]    						=	AutoTokenizer.from_pretrained(__lowercase)
                self.assertIsInstance(__lowercase				,				__lowercase)

        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     UpperCamelCase__     (			self) ->			Optional[int]:
        try:
            AutoConfig.register('''custom'''				,				__lowercase)

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

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

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

            # 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:
                __UpperCamelCase  :str    						=	BertTokenizerFast.from_pretrained(__lowercase)
                bert_tokenizer.save_pretrained(__lowercase)
                __UpperCamelCase  :List[str]    						=	CustomTokenizerFast.from_pretrained(__lowercase)

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

                __UpperCamelCase  :int    						=	AutoTokenizer.from_pretrained(__lowercase)
                self.assertIsInstance(__lowercase				,				__lowercase)

                __UpperCamelCase  :List[str]    						=	AutoTokenizer.from_pretrained(__lowercase				,				use_fast=__lowercase)
                self.assertIsInstance(__lowercase				,				__lowercase)

        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     UpperCamelCase__     (			self) ->			List[str]:
        # If remote code is not set, we will time out when asking whether to load the model.
        with self.assertRaises(__lowercase):
            __UpperCamelCase  :int    						=	AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer''')
        # If remote code is disabled, we can't load this config.
        with self.assertRaises(__lowercase):
            __UpperCamelCase  :Optional[Any]    						=	AutoTokenizer.from_pretrained(
                '''hf-internal-testing/test_dynamic_tokenizer'''				,				trust_remote_code=__lowercase)

        __UpperCamelCase  :Tuple    						=	AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer'''				,				trust_remote_code=__lowercase)
        self.assertTrue(tokenizer.special_attribute_present)
        # Test tokenizer can be reloaded.
        with tempfile.TemporaryDirectory() as tmp_dir:
            tokenizer.save_pretrained(__lowercase)
            __UpperCamelCase  :Tuple    						=	AutoTokenizer.from_pretrained(__lowercase				,				trust_remote_code=__lowercase)
        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
            __UpperCamelCase  :Dict    						=	AutoTokenizer.from_pretrained(
                '''hf-internal-testing/test_dynamic_tokenizer'''				,				trust_remote_code=__lowercase				,				use_fast=__lowercase)
            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(__lowercase)
                __UpperCamelCase  :Tuple    						=	AutoTokenizer.from_pretrained(__lowercase				,				trust_remote_code=__lowercase				,				use_fast=__lowercase)
            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     UpperCamelCase__     (			self) ->			Any:


        class 			lowerCamelCase_  (     UpperCAmelCase_				):






            '''simple docstring'''






            a__			:		Union[str, Any]      			=   False


        class 			lowerCamelCase_  (     UpperCAmelCase_				):






            '''simple docstring'''






            a__			:		str      			=   NewTokenizer
            a__			:		str      			=   False

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

            # If remote code is disabled, we load the local one.
            __UpperCamelCase  :Optional[int]    						=	AutoTokenizer.from_pretrained(
                '''hf-internal-testing/test_dynamic_tokenizer'''				,				trust_remote_code=__lowercase)
            self.assertEqual(tokenizer.__class__.__name__				,				'''NewTokenizerFast''')
            self.assertFalse(tokenizer.special_attribute_present)
            __UpperCamelCase  :Tuple    						=	AutoTokenizer.from_pretrained(
                '''hf-internal-testing/test_dynamic_tokenizer'''				,				trust_remote_code=__lowercase				,				use_fast=__lowercase)
            self.assertEqual(tokenizer.__class__.__name__				,				'''NewTokenizer''')
            self.assertFalse(tokenizer.special_attribute_present)

            # If remote is enabled, we load from the Hub
            __UpperCamelCase  :List[Any]    						=	AutoTokenizer.from_pretrained(
                '''hf-internal-testing/test_dynamic_tokenizer'''				,				trust_remote_code=__lowercase)
            self.assertEqual(tokenizer.__class__.__name__				,				'''NewTokenizerFast''')
            self.assertTrue(tokenizer.special_attribute_present)
            __UpperCamelCase  :Any    						=	AutoTokenizer.from_pretrained(
                '''hf-internal-testing/test_dynamic_tokenizer'''				,				trust_remote_code=__lowercase				,				use_fast=__lowercase)
            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     UpperCamelCase__     (			self) ->			Dict:
        __UpperCamelCase  :List[Any]    						=	AutoTokenizer.from_pretrained(
            '''hf-internal-testing/test_dynamic_tokenizer_legacy'''				,				trust_remote_code=__lowercase)
        self.assertTrue(tokenizer.special_attribute_present)
        if is_tokenizers_available():
            self.assertEqual(tokenizer.__class__.__name__				,				'''NewTokenizerFast''')

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







    def     UpperCamelCase__     (			self) ->			Optional[int]:
        with self.assertRaisesRegex(
            __lowercase				,				'''bert-base is not a local folder and is not a valid model identifier'''):
            __UpperCamelCase  :str    						=	AutoTokenizer.from_pretrained('''bert-base''')







    def     UpperCamelCase__     (			self) ->			List[str]:
        with self.assertRaisesRegex(
            __lowercase				,				r'''aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'''):
            __UpperCamelCase  :Optional[Any]    						=	AutoTokenizer.from_pretrained(__lowercase				,				revision='''aaaaaa''')







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






import functools
import operator

from ...configuration_utils import PretrainedConfig
from ...utils import logging


__lowercase											=      logging.get_logger(__name__)

__lowercase											=      {
    '''microsoft/unispeech-large-1500h-cv''': (
        '''https://huggingface.co/microsoft/unispeech-large-1500h-cv/resolve/main/config.json'''
    ),
    # See all UniSpeech models at https://huggingface.co/models?filter=unispeech
}


class 			lowerCamelCase_  (     UpperCAmelCase_				):






    '''simple docstring'''






    a__			:		Dict      			=   """unispeech"""







    def __init__(			self				,				__lowercase=32				,				__lowercase=768				,				__lowercase=12				,				__lowercase=12				,				__lowercase=3_072				,				__lowercase="gelu"				,				__lowercase=0.1				,				__lowercase=0.1				,				__lowercase=0.1				,				__lowercase=0.0				,				__lowercase=0.0				,				__lowercase=0.1				,				__lowercase=0.1				,				__lowercase=0.02				,				__lowercase=1E-5				,				__lowercase="group"				,				__lowercase="gelu"				,				__lowercase=(512, 512, 512, 512, 512, 512, 512)				,				__lowercase=(5, 2, 2, 2, 2, 2, 2)				,				__lowercase=(10, 3, 3, 3, 3, 2, 2)				,				__lowercase=False				,				__lowercase=128				,				__lowercase=16				,				__lowercase=False				,				__lowercase=True				,				__lowercase=0.05				,				__lowercase=10				,				__lowercase=2				,				__lowercase=0.0				,				__lowercase=10				,				__lowercase=0				,				__lowercase=320				,				__lowercase=2				,				__lowercase=0.1				,				__lowercase=100				,				__lowercase=256				,				__lowercase=256				,				__lowercase=0.1				,				__lowercase="mean"				,				__lowercase=False				,				__lowercase=False				,				__lowercase=256				,				__lowercase=80				,				__lowercase=0				,				__lowercase=1				,				__lowercase=2				,				__lowercase=0.5				,				**__lowercase				,				) ->			Optional[int]:
        super().__init__(**__lowercase				,				pad_token_id=__lowercase				,				bos_token_id=__lowercase				,				eos_token_id=__lowercase)
        __UpperCamelCase  :str    						=	hidden_size
        __UpperCamelCase  :List[str]    						=	feat_extract_norm
        __UpperCamelCase  :str    						=	feat_extract_activation
        __UpperCamelCase  :str    						=	list(__lowercase)
        __UpperCamelCase  :List[Any]    						=	list(__lowercase)
        __UpperCamelCase  :List[Any]    						=	list(__lowercase)
        __UpperCamelCase  :Any    						=	conv_bias
        __UpperCamelCase  :List[Any]    						=	num_conv_pos_embeddings
        __UpperCamelCase  :Tuple    						=	num_conv_pos_embedding_groups
        __UpperCamelCase  :Optional[int]    						=	len(self.conv_dim)
        __UpperCamelCase  :Optional[int]    						=	num_hidden_layers
        __UpperCamelCase  :Union[str, Any]    						=	intermediate_size
        __UpperCamelCase  :Tuple    						=	hidden_act
        __UpperCamelCase  :Optional[int]    						=	num_attention_heads
        __UpperCamelCase  :Any    						=	hidden_dropout
        __UpperCamelCase  :List[str]    						=	attention_dropout
        __UpperCamelCase  :int    						=	activation_dropout
        __UpperCamelCase  :int    						=	feat_proj_dropout
        __UpperCamelCase  :Any    						=	final_dropout
        __UpperCamelCase  :Optional[Any]    						=	layerdrop
        __UpperCamelCase  :Any    						=	layer_norm_eps
        __UpperCamelCase  :List[str]    						=	initializer_range
        __UpperCamelCase  :Tuple    						=	num_ctc_classes
        __UpperCamelCase  :Union[str, Any]    						=	vocab_size
        __UpperCamelCase  :List[Any]    						=	do_stable_layer_norm
        __UpperCamelCase  :Dict    						=	use_weighted_layer_sum
        __UpperCamelCase  :str    						=	classifier_proj_size

        if (
            (len(self.conv_stride) != self.num_feat_extract_layers)
            or (len(self.conv_kernel) != self.num_feat_extract_layers)
            or (len(self.conv_dim) != self.num_feat_extract_layers)
        ):
            raise ValueError(
                '''Configuration for convolutional layers is incorrect. It is required that `len(config.conv_dim)` =='''
                ''' `len(config.conv_stride)` == `len(config.conv_kernel)`, but is `len(config.conv_dim) ='''
                f""" {len(self.conv_dim)}`, `len(config.conv_stride) = {len(self.conv_stride)}`,"""
                f""" `len(config.conv_kernel) = {len(self.conv_kernel)}`.""")

        # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
        __UpperCamelCase  :List[Any]    						=	apply_spec_augment
        __UpperCamelCase  :Optional[int]    						=	mask_time_prob
        __UpperCamelCase  :int    						=	mask_time_length
        __UpperCamelCase  :Any    						=	mask_time_min_masks
        __UpperCamelCase  :Any    						=	mask_feature_prob
        __UpperCamelCase  :str    						=	mask_feature_length
        __UpperCamelCase  :Tuple    						=	mask_feature_min_masks

        # parameters for pretraining with codevector quantized representations
        __UpperCamelCase  :Optional[Any]    						=	num_codevectors_per_group
        __UpperCamelCase  :Dict    						=	num_codevector_groups
        __UpperCamelCase  :Optional[int]    						=	contrastive_logits_temperature
        __UpperCamelCase  :Union[str, Any]    						=	feat_quantizer_dropout
        __UpperCamelCase  :List[str]    						=	num_negatives
        __UpperCamelCase  :Union[str, Any]    						=	codevector_dim
        __UpperCamelCase  :int    						=	proj_codevector_dim
        __UpperCamelCase  :Tuple    						=	diversity_loss_weight

        # ctc loss
        __UpperCamelCase  :List[Any]    						=	ctc_loss_reduction
        __UpperCamelCase  :int    						=	ctc_zero_infinity

        # pretraining loss
        __UpperCamelCase  :Optional[Any]    						=	replace_prob







    @property
    def     UpperCamelCase__     (			self) ->			Dict:
        return functools.reduce(operator.mul				,				self.conv_stride				,				1)





