"""simple docstring"""




from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


_UpperCAmelCase            =		{
    "configuration_electra": ["ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP", "ElectraConfig", "ElectraOnnxConfig"],
    "tokenization_electra": ["ElectraTokenizer"],
}

try:
	if not is_tokenizers_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	_UpperCAmelCase            =		["ElectraTokenizerFast"]

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	_UpperCAmelCase            =		[
	    "ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST",
	    "ElectraForCausalLM",
	    "ElectraForMaskedLM",
	    "ElectraForMultipleChoice",
	    "ElectraForPreTraining",
	    "ElectraForQuestionAnswering",
	    "ElectraForSequenceClassification",
	    "ElectraForTokenClassification",
	    "ElectraModel",
	    "ElectraPreTrainedModel",
	    "load_tf_weights_in_electra",
	]

try:
	if not is_tf_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	_UpperCAmelCase            =		[
	    "TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST",
	    "TFElectraForMaskedLM",
	    "TFElectraForMultipleChoice",
	    "TFElectraForPreTraining",
	    "TFElectraForQuestionAnswering",
	    "TFElectraForSequenceClassification",
	    "TFElectraForTokenClassification",
	    "TFElectraModel",
	    "TFElectraPreTrainedModel",
	]

try:
	if not is_flax_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	_UpperCAmelCase            =		[
	    "FlaxElectraForCausalLM",
	    "FlaxElectraForMaskedLM",
	    "FlaxElectraForMultipleChoice",
	    "FlaxElectraForPreTraining",
	    "FlaxElectraForQuestionAnswering",
	    "FlaxElectraForSequenceClassification",
	    "FlaxElectraForTokenClassification",
	    "FlaxElectraModel",
	    "FlaxElectraPreTrainedModel",
	]


if TYPE_CHECKING:
	from .configuration_electra import ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, ElectraConfig, ElectraOnnxConfig
	from .tokenization_electra import ElectraTokenizer

	try:
		if not is_tokenizers_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .tokenization_electra_fast import ElectraTokenizerFast

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_electra import (
		    ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST,
		    ElectraForCausalLM,
		    ElectraForMaskedLM,
		    ElectraForMultipleChoice,
		    ElectraForPreTraining,
		    ElectraForQuestionAnswering,
		    ElectraForSequenceClassification,
		    ElectraForTokenClassification,
		    ElectraModel,
		    ElectraPreTrainedModel,
		    load_tf_weights_in_electra,
		)

	try:
		if not is_tf_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_tf_electra import (
		    TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TFElectraForMaskedLM,
		    TFElectraForMultipleChoice,
		    TFElectraForPreTraining,
		    TFElectraForQuestionAnswering,
		    TFElectraForSequenceClassification,
		    TFElectraForTokenClassification,
		    TFElectraModel,
		    TFElectraPreTrainedModel,
		)

	try:
		if not is_flax_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_flax_electra import (
		    FlaxElectraForCausalLM,
		    FlaxElectraForMaskedLM,
		    FlaxElectraForMultipleChoice,
		    FlaxElectraForPreTraining,
		    FlaxElectraForQuestionAnswering,
		    FlaxElectraForSequenceClassification,
		    FlaxElectraForTokenClassification,
		    FlaxElectraModel,
		    FlaxElectraPreTrainedModel,
		)

else:
	import sys

	_UpperCAmelCase            =		_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)







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


_UpperCAmelCase            =		logging.get_logger(__name__)

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

_UpperCAmelCase            =		{
    """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"""
        ),
    },
}

_UpperCAmelCase            =		{
    """squeezebert/squeezebert-uncased""": 512,
    """squeezebert/squeezebert-mnli""": 512,
    """squeezebert/squeezebert-mnli-headless""": 512,
}


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





class UpperCAmelCase						( __A  ):


				'''simple docstring'''






				lowerCamelCase_    = VOCAB_FILES_NAMES
				lowerCamelCase_    = PRETRAINED_VOCAB_FILES_MAP
				lowerCamelCase_    = PRETRAINED_INIT_CONFIGURATION
				lowerCamelCase_    = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				lowerCamelCase_    = SqueezeBertTokenizer
				def __init__(						self		,     lowercase=None		,     lowercase=None		,     lowercase=True		,     lowercase="[UNK]"		,     lowercase="[SEP]"		,     lowercase="[PAD]"		,     lowercase="[CLS]"		,     lowercase="[MASK]"		,     lowercase=True		,     lowercase=None		,     **lowercase		,     ):



						"""simple docstring"""





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

						A_		:    int         =				json.loads(self.backend_tokenizer.normalizer.__getstate__() )
						if (
						    normalizer_state.get('lowercase'		,     lowercase ) != do_lower_case
						    or normalizer_state.get('strip_accents'		,     lowercase ) != strip_accents
						    or normalizer_state.get('handle_chinese_chars'		,     lowercase ) != tokenize_chinese_chars
						):
								A_		:    Dict         =				getattr(lowercase		,     normalizer_state.pop('type' ) )
								A_		:    Optional[int]         =				do_lower_case
								A_		:    Optional[Any]         =				strip_accents
								A_		:    str         =				tokenize_chinese_chars
								A_		:    Any         =				normalizer_class(**lowercase )

						A_		:    Tuple         =				do_lower_case
				def   lowerCAmelCase_       (						self		,     lowercase		,     lowercase=None ):



						"""simple docstring"""





						A_		:    str         =				[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		,     lowercase		,     lowercase = None ):



						"""simple docstring"""





						A_		:    Dict         =				[self.sep_token_id]
						A_		:    Union[str, Any]         =				[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   lowerCAmelCase_       (						self		,     lowercase		,     lowercase = None ):



						"""simple docstring"""





						A_		:    Dict         =				self._tokenizer.model.save(lowercase		,     name=lowercase )
						return tuple(lowercase )






