




'''simple docstring'''


from collections import OrderedDict
from typing import Mapping

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


_snake_case : int  				=						logging.get_logger(__name__)

_snake_case : Optional[Any]  				=						{
    'bert-base-uncased': 'https://huggingface.co/bert-base-uncased/resolve/main/config.json',
    'bert-large-uncased': 'https://huggingface.co/bert-large-uncased/resolve/main/config.json',
    'bert-base-cased': 'https://huggingface.co/bert-base-cased/resolve/main/config.json',
    'bert-large-cased': 'https://huggingface.co/bert-large-cased/resolve/main/config.json',
    'bert-base-multilingual-uncased': 'https://huggingface.co/bert-base-multilingual-uncased/resolve/main/config.json',
    'bert-base-multilingual-cased': 'https://huggingface.co/bert-base-multilingual-cased/resolve/main/config.json',
    'bert-base-chinese': 'https://huggingface.co/bert-base-chinese/resolve/main/config.json',
    'bert-base-german-cased': 'https://huggingface.co/bert-base-german-cased/resolve/main/config.json',
    'bert-large-uncased-whole-word-masking': (
        'https://huggingface.co/bert-large-uncased-whole-word-masking/resolve/main/config.json'
    ),
    'bert-large-cased-whole-word-masking': (
        'https://huggingface.co/bert-large-cased-whole-word-masking/resolve/main/config.json'
    ),
    'bert-large-uncased-whole-word-masking-finetuned-squad': (
        'https://huggingface.co/bert-large-uncased-whole-word-masking-finetuned-squad/resolve/main/config.json'
    ),
    'bert-large-cased-whole-word-masking-finetuned-squad': (
        'https://huggingface.co/bert-large-cased-whole-word-masking-finetuned-squad/resolve/main/config.json'
    ),
    'bert-base-cased-finetuned-mrpc': 'https://huggingface.co/bert-base-cased-finetuned-mrpc/resolve/main/config.json',
    'bert-base-german-dbmdz-cased': 'https://huggingface.co/bert-base-german-dbmdz-cased/resolve/main/config.json',
    'bert-base-german-dbmdz-uncased': 'https://huggingface.co/bert-base-german-dbmdz-uncased/resolve/main/config.json',
    'cl-tohoku/bert-base-japanese': 'https://huggingface.co/cl-tohoku/bert-base-japanese/resolve/main/config.json',
    'cl-tohoku/bert-base-japanese-whole-word-masking': (
        'https://huggingface.co/cl-tohoku/bert-base-japanese-whole-word-masking/resolve/main/config.json'
    ),
    'cl-tohoku/bert-base-japanese-char': (
        'https://huggingface.co/cl-tohoku/bert-base-japanese-char/resolve/main/config.json'
    ),
    'cl-tohoku/bert-base-japanese-char-whole-word-masking': (
        'https://huggingface.co/cl-tohoku/bert-base-japanese-char-whole-word-masking/resolve/main/config.json'
    ),
    'TurkuNLP/bert-base-finnish-cased-v1': (
        'https://huggingface.co/TurkuNLP/bert-base-finnish-cased-v1/resolve/main/config.json'
    ),
    'TurkuNLP/bert-base-finnish-uncased-v1': (
        'https://huggingface.co/TurkuNLP/bert-base-finnish-uncased-v1/resolve/main/config.json'
    ),
    'wietsedv/bert-base-dutch-cased': 'https://huggingface.co/wietsedv/bert-base-dutch-cased/resolve/main/config.json',
    # See all BERT models at https://huggingface.co/models?filter=bert
}

class      A       (						_a       ):
							lowercase_							     =							'bert'







							def __init__(    self			:    Union[str, Any]				,     lowerCAmelCase_			:    Dict=3_05_22				,     lowerCAmelCase_			:    Tuple=7_68				,     lowerCAmelCase_			:    Any=12				,     lowerCAmelCase_			:    List[str]=12				,     lowerCAmelCase_			:    List[Any]=30_72				,     lowerCAmelCase_			:    int="gelu"				,     lowerCAmelCase_			:    int=0.1				,     lowerCAmelCase_			:    List[str]=0.1				,     lowerCAmelCase_			:    List[Any]=5_12				,     lowerCAmelCase_			:    Dict=2				,     lowerCAmelCase_			:    List[Any]=0.0_2				,     lowerCAmelCase_			:    Any=1e-12				,     lowerCAmelCase_			:    str=0				,     lowerCAmelCase_			:    Optional[Any]="absolute"				,     lowerCAmelCase_			:    Optional[Any]=True				,     lowerCAmelCase_			:    Optional[Any]=None				,     **lowerCAmelCase_			:    Optional[Any]				,     )     ->				List[str]:


														"""simple docstring"""


														super().__init__(pad_token_id=lowerCAmelCase_				,     **lowerCAmelCase_   )

														_a      	=							vocab_size
														_a      	=							hidden_size
														_a      	=							num_hidden_layers
														_a      	=							num_attention_heads
														_a      	=							hidden_act
														_a      	=							intermediate_size
														_a      	=							hidden_dropout_prob
														_a      	=							attention_probs_dropout_prob
														_a      	=							max_position_embeddings
														_a      	=							type_vocab_size
														_a      	=							initializer_range
														_a      	=							layer_norm_eps
														_a      	=							position_embedding_type
														_a      	=							use_cache
														_a      	=							classifier_dropout



class      A       (						_a       ):







							@property
							def   __lowerCAmelCase     (    self			:    Tuple   )     ->				Mapping[str, Mapping[int, str]]:


														"""simple docstring"""


														if self.task == "multiple-choice":
																					_a      	=							{0: '''batch''', 1: '''choice''', 2: '''sequence'''}
														else:
																					_a      	=							{0: '''batch''', 1: '''sequence'''}
														return OrderedDict(
														    [
														        ('''input_ids''', dynamic_axis),
														        ('''attention_mask''', dynamic_axis),
														        ('''token_type_ids''', dynamic_axis),
														    ]   )







'''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_squeezebert import SqueezeBertTokenizer


_snake_case : Tuple  				=						logging.get_logger(__name__)

_snake_case : Optional[int]  				=						{'vocab_file': 'vocab.txt', 'tokenizer_file': 'tokenizer.json'}

_snake_case : List[Any]  				=						{
    '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 : Union[str, Any]  				=						{
    'squeezebert/squeezebert-uncased': 512,
    'squeezebert/squeezebert-mnli': 512,
    'squeezebert/squeezebert-mnli-headless': 512,
}


_snake_case : Tuple  				=						{
    'squeezebert/squeezebert-uncased': {'do_lower_case': True},
    'squeezebert/squeezebert-mnli': {'do_lower_case': True},
    'squeezebert/squeezebert-mnli-headless': {'do_lower_case': True},
}

class      A       (						_a       ):
							lowercase_							     =							VOCAB_FILES_NAMES
							lowercase_							     =							PRETRAINED_VOCAB_FILES_MAP
							lowercase_							     =							PRETRAINED_INIT_CONFIGURATION
							lowercase_							     =							PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
							lowercase_							     =							SqueezeBertTokenizer







							def __init__(    self			:    str				,     lowerCAmelCase_			:    str=None				,     lowerCAmelCase_			:    List[str]=None				,     lowerCAmelCase_			:    str=True				,     lowerCAmelCase_			:    List[str]="[UNK]"				,     lowerCAmelCase_			:    Union[str, Any]="[SEP]"				,     lowerCAmelCase_			:    Optional[Any]="[PAD]"				,     lowerCAmelCase_			:    Any="[CLS]"				,     lowerCAmelCase_			:    List[str]="[MASK]"				,     lowerCAmelCase_			:    int=True				,     lowerCAmelCase_			:    List[Any]=None				,     **lowerCAmelCase_			:    Optional[int]				,     )     ->				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_				,     tokenize_chinese_chars=lowerCAmelCase_				,     strip_accents=lowerCAmelCase_				,     **lowerCAmelCase_				,     )

														_a      	=							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
														):
																					_a      	=							getattr(lowerCAmelCase_				,     normalizer_state.pop('''type'''   )   )
																					_a      	=							do_lower_case
																					_a      	=							strip_accents
																					_a      	=							tokenize_chinese_chars
																					_a      	=							normalizer_class(**lowerCAmelCase_   )

														_a      	=							do_lower_case







							def   __lowerCAmelCase     (    self			:    Union[str, Any]				,     lowerCAmelCase_			:    int				,     lowerCAmelCase_			:    Optional[Any]=None   )     ->				List[str]:


														"""simple docstring"""


														_a      	=							[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			:    Any				,     lowerCAmelCase_			:    List[int]				,     lowerCAmelCase_			:    Optional[List[int]] = None   )     ->				List[int]:


														"""simple docstring"""


														_a      	=							[self.sep_token_id]
														_a      	=							[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			:    Optional[Any]				,     lowerCAmelCase_			:    str				,     lowerCAmelCase_			:    Optional[str] = None   )     ->				Tuple[str]:


														"""simple docstring"""


														_a      	=							self._tokenizer.model.save(lowerCAmelCase_				,     name=lowerCAmelCase_   )
														return tuple(lowerCAmelCase_   )

