


import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_squeezebert import SqueezeBertTokenizer


__snake_case									=		logging.get_logger(__name__)

__snake_case									=		{"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"}

__snake_case									=		{
    "vocab_file": {
        "squeezebert/squeezebert-uncased": (
            "https://huggingface.co/squeezebert/squeezebert-uncased/resolve/main/vocab.txt"
        ),
        "squeezebert/squeezebert-mnli": "https://huggingface.co/squeezebert/squeezebert-mnli/resolve/main/vocab.txt",
        "squeezebert/squeezebert-mnli-headless": (
            "https://huggingface.co/squeezebert/squeezebert-mnli-headless/resolve/main/vocab.txt"
        ),
    },
    "tokenizer_file": {
        "squeezebert/squeezebert-uncased": (
            "https://huggingface.co/squeezebert/squeezebert-uncased/resolve/main/tokenizer.json"
        ),
        "squeezebert/squeezebert-mnli": (
            "https://huggingface.co/squeezebert/squeezebert-mnli/resolve/main/tokenizer.json"
        ),
        "squeezebert/squeezebert-mnli-headless": (
            "https://huggingface.co/squeezebert/squeezebert-mnli-headless/resolve/main/tokenizer.json"
        ),
    },
}

__snake_case									=		{
    "squeezebert/squeezebert-uncased": 5_1_2,
    "squeezebert/squeezebert-mnli": 5_1_2,
    "squeezebert/squeezebert-mnli-headless": 5_1_2,
}


__snake_case									=		{
    "squeezebert/squeezebert-uncased": {"do_lower_case": True},
    "squeezebert/squeezebert-mnli": {"do_lower_case": True},
    "squeezebert/squeezebert-mnli-headless": {"do_lower_case": True},
}



class      __lowerCamelCase       (a_		):
       _lowercase											=			VOCAB_FILES_NAMES
       _lowercase											=			PRETRAINED_VOCAB_FILES_MAP
       _lowercase											=			PRETRAINED_INIT_CONFIGURATION
       _lowercase											=			PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
       _lowercase											=			SqueezeBertTokenizer







       def __init__(       self:      int,A_:      Any=None,A_:      List[Any]=None,A_:      Tuple=True,A_:      Optional[int]="[UNK]",A_:      Optional[int]="[SEP]",A_:      int="[PAD]",A_:      Union[str, Any]="[CLS]",A_:      Tuple="[MASK]",A_:      Tuple=True,A_:      str=None,**A_:      int,):






            '''simple docstring'''




            super().__init__(
                _A,tokenizer_file=_A,do_lower_case=_A,unk_token=_A,sep_token=_A,pad_token=_A,cls_token=_A,mask_token=_A,tokenize_chinese_chars=_A,strip_accents=_A,**_A,)

            __UpperCamelCase      =       json.loads(self.backend_tokenizer.normalizer.__getstate__() )
            if (
                normalizer_state.get('lowercase',_A ) != do_lower_case
                or normalizer_state.get('strip_accents',_A ) != strip_accents
                or normalizer_state.get('handle_chinese_chars',_A ) != tokenize_chinese_chars
            ):
                 __UpperCamelCase      =       getattr(_A,normalizer_state.pop('type' ) )
                 __UpperCamelCase      =       do_lower_case
                 __UpperCamelCase      =       strip_accents
                 __UpperCamelCase      =       tokenize_chinese_chars
                 __UpperCamelCase      =       normalizer_class(**_A )

            __UpperCamelCase      =       do_lower_case







       def 						snake_case_     (       self:      List[Any],A_:      int,A_:      int=None ):






            '''simple docstring'''




            __UpperCamelCase      =       [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 						snake_case_     (       self:      Any,A_:      Dict,A_:      List[Any] = None ):






            '''simple docstring'''




            __UpperCamelCase      =       [self.sep_token_id]
            __UpperCamelCase      =       [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 ) * [0] + len(token_ids_a + sep ) * [1]







       def 						snake_case_     (       self:      Optional[int],A_:      int,A_:      Any = None ):






            '''simple docstring'''




            __UpperCamelCase      =       self._tokenizer.model.save(_A,name=_A )
            return tuple(_A )









from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_speech_available,
    is_tf_available,
    is_torch_available,
)


__A				:    Union[str, Any]       =   {
    "configuration_speech_to_text": ["SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP", "Speech2TextConfig"],
    "processing_speech_to_text": ["Speech2TextProcessor"],
}

try:
				if not is_sentencepiece_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__A				:    List[Any]       =   ["Speech2TextTokenizer"]

try:
				if not is_speech_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__A				:    List[Any]       =   ["Speech2TextFeatureExtractor"]

try:
				if not is_tf_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__A				:    int       =   [
				    "TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST",
				    "TFSpeech2TextForConditionalGeneration",
				    "TFSpeech2TextModel",
				    "TFSpeech2TextPreTrainedModel",
				]

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__A				:    Tuple       =   [
				    "SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST",
				    "Speech2TextForConditionalGeneration",
				    "Speech2TextModel",
				    "Speech2TextPreTrainedModel",
				]


if TYPE_CHECKING:
				from .configuration_speech_to_text import SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP, SpeechaTextConfig
				from .processing_speech_to_text import SpeechaTextProcessor

				try:
								if not is_sentencepiece_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .tokenization_speech_to_text import SpeechaTextTokenizer

				try:
								if not is_speech_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .feature_extraction_speech_to_text import SpeechaTextFeatureExtractor

				try:
								if not is_tf_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_tf_speech_to_text import (
								    TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
								    TFSpeechaTextForConditionalGeneration,
								    TFSpeechaTextModel,
								    TFSpeechaTextPreTrainedModel,
								)

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_speech_to_text import (
								    SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
								    SpeechaTextForConditionalGeneration,
								    SpeechaTextModel,
								    SpeechaTextPreTrainedModel,
								)

else:
				import sys

				__A				:    Dict       =   _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



