


'''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_distilbert import DistilBertTokenizer


A__						:   List[str]				=    logging.get_logger(__name__)

A__						:   Optional[Any]				=    {"""vocab_file""": """vocab.txt""", """tokenizer_file""": """tokenizer.json"""}

A__						:   Any				=    {
    """vocab_file""": {
        """distilbert-base-uncased""": """https://huggingface.co/distilbert-base-uncased/resolve/main/vocab.txt""",
        """distilbert-base-uncased-distilled-squad""": (
            """https://huggingface.co/distilbert-base-uncased-distilled-squad/resolve/main/vocab.txt"""
        ),
        """distilbert-base-cased""": """https://huggingface.co/distilbert-base-cased/resolve/main/vocab.txt""",
        """distilbert-base-cased-distilled-squad""": (
            """https://huggingface.co/distilbert-base-cased-distilled-squad/resolve/main/vocab.txt"""
        ),
        """distilbert-base-german-cased""": """https://huggingface.co/distilbert-base-german-cased/resolve/main/vocab.txt""",
        """distilbert-base-multilingual-cased""": (
            """https://huggingface.co/distilbert-base-multilingual-cased/resolve/main/vocab.txt"""
        ),
    },
    """tokenizer_file""": {
        """distilbert-base-uncased""": """https://huggingface.co/distilbert-base-uncased/resolve/main/tokenizer.json""",
        """distilbert-base-uncased-distilled-squad""": (
            """https://huggingface.co/distilbert-base-uncased-distilled-squad/resolve/main/tokenizer.json"""
        ),
        """distilbert-base-cased""": """https://huggingface.co/distilbert-base-cased/resolve/main/tokenizer.json""",
        """distilbert-base-cased-distilled-squad""": (
            """https://huggingface.co/distilbert-base-cased-distilled-squad/resolve/main/tokenizer.json"""
        ),
        """distilbert-base-german-cased""": (
            """https://huggingface.co/distilbert-base-german-cased/resolve/main/tokenizer.json"""
        ),
        """distilbert-base-multilingual-cased""": (
            """https://huggingface.co/distilbert-base-multilingual-cased/resolve/main/tokenizer.json"""
        ),
    },
}

A__						:   str				=    {
    """distilbert-base-uncased""": 512,
    """distilbert-base-uncased-distilled-squad""": 512,
    """distilbert-base-cased""": 512,
    """distilbert-base-cased-distilled-squad""": 512,
    """distilbert-base-german-cased""": 512,
    """distilbert-base-multilingual-cased""": 512,
}


A__						:   Any				=    {
    """distilbert-base-uncased""": {"""do_lower_case""": True},
    """distilbert-base-uncased-distilled-squad""": {"""do_lower_case""": True},
    """distilbert-base-cased""": {"""do_lower_case""": False},
    """distilbert-base-cased-distilled-squad""": {"""do_lower_case""": False},
    """distilbert-base-german-cased""": {"""do_lower_case""": False},
    """distilbert-base-multilingual-cased""": {"""do_lower_case""": False},
}





class   UpperCAmelCase_    (_UpperCAmelCase    ):





    """simple docstring"""






    lowerCamelCase    :   List[str]					=     VOCAB_FILES_NAMES
    lowerCamelCase    :   Dict					=     PRETRAINED_VOCAB_FILES_MAP
    lowerCamelCase    :   Tuple					=     PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
    lowerCamelCase    :   Any					=     PRETRAINED_INIT_CONFIGURATION
    lowerCamelCase    :   Any					=     ['input_ids', 'attention_mask']
    lowerCamelCase    :   Optional[Any]					=     DistilBertTokenizer







    def __init__(				self     ,	SCREAMING_SNAKE_CASE_=None     ,	SCREAMING_SNAKE_CASE_=None     ,	SCREAMING_SNAKE_CASE_=True     ,	SCREAMING_SNAKE_CASE_="[UNK]"     ,	SCREAMING_SNAKE_CASE_="[SEP]"     ,	SCREAMING_SNAKE_CASE_="[PAD]"     ,	SCREAMING_SNAKE_CASE_="[CLS]"     ,	SCREAMING_SNAKE_CASE_="[MASK]"     ,	SCREAMING_SNAKE_CASE_=True     ,	SCREAMING_SNAKE_CASE_=None     ,	**SCREAMING_SNAKE_CASE_     ,	)							->	Union[str, Any]:
         super().__init__(
             SCREAMING_SNAKE_CASE_     ,	tokenizer_file=SCREAMING_SNAKE_CASE_     ,	do_lower_case=SCREAMING_SNAKE_CASE_     ,	unk_token=SCREAMING_SNAKE_CASE_     ,	sep_token=SCREAMING_SNAKE_CASE_     ,	pad_token=SCREAMING_SNAKE_CASE_     ,	cls_token=SCREAMING_SNAKE_CASE_     ,	mask_token=SCREAMING_SNAKE_CASE_     ,	tokenize_chinese_chars=SCREAMING_SNAKE_CASE_     ,	strip_accents=SCREAMING_SNAKE_CASE_     ,	**SCREAMING_SNAKE_CASE_     ,	)

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

         __lowerCamelCase  :      Optional[int]														=						do_lower_case







    def  lowercase_							(				self     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_=None      )							->	Any:
         __lowerCamelCase  :      Optional[int]														=						[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  lowercase_							(				self     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_ = None      )							->	List[int]:
         __lowerCamelCase  :      Dict														=						[self.sep_token_id]
         __lowerCamelCase  :      str														=						[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  lowercase_							(				self     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_ = None      )							->	Tuple[str]:
         __lowerCamelCase  :      List[Any]														=						self._tokenizer.model.save(SCREAMING_SNAKE_CASE_     ,	name=SCREAMING_SNAKE_CASE_      )
         return tuple(SCREAMING_SNAKE_CASE_      )








"""simple docstring"""

from collections import OrderedDict
from typing import Mapping

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


SCREAMING_SNAKE_CASE_            =    logging.get_logger(__name__)

SCREAMING_SNAKE_CASE_            =    {
    '''kssteven/ibert-roberta-base''': '''https://huggingface.co/kssteven/ibert-roberta-base/resolve/main/config.json''',
    '''kssteven/ibert-roberta-large''': '''https://huggingface.co/kssteven/ibert-roberta-large/resolve/main/config.json''',
    '''kssteven/ibert-roberta-large-mnli''': (
        '''https://huggingface.co/kssteven/ibert-roberta-large-mnli/resolve/main/config.json'''
    ),
}
class   _UpperCAmelCase				(		SCREAMING_SNAKE_CASE_				):
      __SCREAMING_SNAKE_CASE :				Tuple				   =						"ibert"




      def __init__(				self ,							lowercase_=3_0_5_2_2 ,							lowercase_=7_6_8 ,							lowercase_=1_2 ,							lowercase_=1_2 ,							lowercase_=3_0_7_2 ,							lowercase_="gelu" ,							lowercase_=0.1 ,							lowercase_=0.1 ,							lowercase_=5_1_2 ,							lowercase_=2 ,							lowercase_=0.0_2 ,							lowercase_=1E-12 ,							lowercase_=1 ,							lowercase_=0 ,							lowercase_=2 ,							lowercase_="absolute" ,							lowercase_=False ,							lowercase_="none" ,							**lowercase_ ,							)    ->       Optional[int]:
          super().__init__(pad_token_id=lowercase_ ,							bos_token_id=lowercase_ ,							eos_token_id=lowercase_ ,							**lowercase_				)

          UpperCAmelCase          =       vocab_size
          UpperCAmelCase          =       hidden_size
          UpperCAmelCase          =       num_hidden_layers
          UpperCAmelCase          =       num_attention_heads
          UpperCAmelCase          =       hidden_act
          UpperCAmelCase          =       intermediate_size
          UpperCAmelCase          =       hidden_dropout_prob
          UpperCAmelCase          =       attention_probs_dropout_prob
          UpperCAmelCase          =       max_position_embeddings
          UpperCAmelCase          =       type_vocab_size
          UpperCAmelCase          =       initializer_range
          UpperCAmelCase          =       layer_norm_eps
          UpperCAmelCase          =       position_embedding_type
          UpperCAmelCase          =       quant_mode
          UpperCAmelCase          =       force_dequant

class   _UpperCAmelCase				(		SCREAMING_SNAKE_CASE_				):




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



