





import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_bert import BertTokenizer


_snake_case  :   Dict						   =  logging.get_logger(__name__)

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

_snake_case  :   Optional[int]						   =  {
    'vocab_file': {
        'bert-base-uncased': 'https://huggingface.co/bert-base-uncased/resolve/main/vocab.txt',
        'bert-large-uncased': 'https://huggingface.co/bert-large-uncased/resolve/main/vocab.txt',
        'bert-base-cased': 'https://huggingface.co/bert-base-cased/resolve/main/vocab.txt',
        'bert-large-cased': 'https://huggingface.co/bert-large-cased/resolve/main/vocab.txt',
        'bert-base-multilingual-uncased': (
            'https://huggingface.co/bert-base-multilingual-uncased/resolve/main/vocab.txt'
        ),
        'bert-base-multilingual-cased': 'https://huggingface.co/bert-base-multilingual-cased/resolve/main/vocab.txt',
        'bert-base-chinese': 'https://huggingface.co/bert-base-chinese/resolve/main/vocab.txt',
        'bert-base-german-cased': 'https://huggingface.co/bert-base-german-cased/resolve/main/vocab.txt',
        'bert-large-uncased-whole-word-masking': (
            'https://huggingface.co/bert-large-uncased-whole-word-masking/resolve/main/vocab.txt'
        ),
        'bert-large-cased-whole-word-masking': (
            'https://huggingface.co/bert-large-cased-whole-word-masking/resolve/main/vocab.txt'
        ),
        'bert-large-uncased-whole-word-masking-finetuned-squad': (
            'https://huggingface.co/bert-large-uncased-whole-word-masking-finetuned-squad/resolve/main/vocab.txt'
        ),
        'bert-large-cased-whole-word-masking-finetuned-squad': (
            'https://huggingface.co/bert-large-cased-whole-word-masking-finetuned-squad/resolve/main/vocab.txt'
        ),
        'bert-base-cased-finetuned-mrpc': (
            'https://huggingface.co/bert-base-cased-finetuned-mrpc/resolve/main/vocab.txt'
        ),
        'bert-base-german-dbmdz-cased': 'https://huggingface.co/bert-base-german-dbmdz-cased/resolve/main/vocab.txt',
        'bert-base-german-dbmdz-uncased': (
            'https://huggingface.co/bert-base-german-dbmdz-uncased/resolve/main/vocab.txt'
        ),
        'TurkuNLP/bert-base-finnish-cased-v1': (
            'https://huggingface.co/TurkuNLP/bert-base-finnish-cased-v1/resolve/main/vocab.txt'
        ),
        'TurkuNLP/bert-base-finnish-uncased-v1': (
            'https://huggingface.co/TurkuNLP/bert-base-finnish-uncased-v1/resolve/main/vocab.txt'
        ),
        'wietsedv/bert-base-dutch-cased': (
            'https://huggingface.co/wietsedv/bert-base-dutch-cased/resolve/main/vocab.txt'
        ),
    },
    'tokenizer_file': {
        'bert-base-uncased': 'https://huggingface.co/bert-base-uncased/resolve/main/tokenizer.json',
        'bert-large-uncased': 'https://huggingface.co/bert-large-uncased/resolve/main/tokenizer.json',
        'bert-base-cased': 'https://huggingface.co/bert-base-cased/resolve/main/tokenizer.json',
        'bert-large-cased': 'https://huggingface.co/bert-large-cased/resolve/main/tokenizer.json',
        'bert-base-multilingual-uncased': (
            'https://huggingface.co/bert-base-multilingual-uncased/resolve/main/tokenizer.json'
        ),
        'bert-base-multilingual-cased': (
            'https://huggingface.co/bert-base-multilingual-cased/resolve/main/tokenizer.json'
        ),
        'bert-base-chinese': 'https://huggingface.co/bert-base-chinese/resolve/main/tokenizer.json',
        'bert-base-german-cased': 'https://huggingface.co/bert-base-german-cased/resolve/main/tokenizer.json',
        'bert-large-uncased-whole-word-masking': (
            'https://huggingface.co/bert-large-uncased-whole-word-masking/resolve/main/tokenizer.json'
        ),
        'bert-large-cased-whole-word-masking': (
            'https://huggingface.co/bert-large-cased-whole-word-masking/resolve/main/tokenizer.json'
        ),
        'bert-large-uncased-whole-word-masking-finetuned-squad': (
            'https://huggingface.co/bert-large-uncased-whole-word-masking-finetuned-squad/resolve/main/tokenizer.json'
        ),
        'bert-large-cased-whole-word-masking-finetuned-squad': (
            'https://huggingface.co/bert-large-cased-whole-word-masking-finetuned-squad/resolve/main/tokenizer.json'
        ),
        'bert-base-cased-finetuned-mrpc': (
            'https://huggingface.co/bert-base-cased-finetuned-mrpc/resolve/main/tokenizer.json'
        ),
        'bert-base-german-dbmdz-cased': (
            'https://huggingface.co/bert-base-german-dbmdz-cased/resolve/main/tokenizer.json'
        ),
        'bert-base-german-dbmdz-uncased': (
            'https://huggingface.co/bert-base-german-dbmdz-uncased/resolve/main/tokenizer.json'
        ),
        'TurkuNLP/bert-base-finnish-cased-v1': (
            'https://huggingface.co/TurkuNLP/bert-base-finnish-cased-v1/resolve/main/tokenizer.json'
        ),
        'TurkuNLP/bert-base-finnish-uncased-v1': (
            'https://huggingface.co/TurkuNLP/bert-base-finnish-uncased-v1/resolve/main/tokenizer.json'
        ),
        'wietsedv/bert-base-dutch-cased': (
            'https://huggingface.co/wietsedv/bert-base-dutch-cased/resolve/main/tokenizer.json'
        ),
    },
}

_snake_case  :   int						   =  {
    'bert-base-uncased': 512,
    'bert-large-uncased': 512,
    'bert-base-cased': 512,
    'bert-large-cased': 512,
    'bert-base-multilingual-uncased': 512,
    'bert-base-multilingual-cased': 512,
    'bert-base-chinese': 512,
    'bert-base-german-cased': 512,
    'bert-large-uncased-whole-word-masking': 512,
    'bert-large-cased-whole-word-masking': 512,
    'bert-large-uncased-whole-word-masking-finetuned-squad': 512,
    'bert-large-cased-whole-word-masking-finetuned-squad': 512,
    'bert-base-cased-finetuned-mrpc': 512,
    'bert-base-german-dbmdz-cased': 512,
    'bert-base-german-dbmdz-uncased': 512,
    'TurkuNLP/bert-base-finnish-cased-v1': 512,
    'TurkuNLP/bert-base-finnish-uncased-v1': 512,
    'wietsedv/bert-base-dutch-cased': 512,
}

_snake_case  :   Dict						   =  {
    'bert-base-uncased': {'do_lower_case': True},
    'bert-large-uncased': {'do_lower_case': True},
    'bert-base-cased': {'do_lower_case': False},
    'bert-large-cased': {'do_lower_case': False},
    'bert-base-multilingual-uncased': {'do_lower_case': True},
    'bert-base-multilingual-cased': {'do_lower_case': False},
    'bert-base-chinese': {'do_lower_case': False},
    'bert-base-german-cased': {'do_lower_case': False},
    'bert-large-uncased-whole-word-masking': {'do_lower_case': True},
    'bert-large-cased-whole-word-masking': {'do_lower_case': False},
    'bert-large-uncased-whole-word-masking-finetuned-squad': {'do_lower_case': True},
    'bert-large-cased-whole-word-masking-finetuned-squad': {'do_lower_case': False},
    'bert-base-cased-finetuned-mrpc': {'do_lower_case': False},
    'bert-base-german-dbmdz-cased': {'do_lower_case': False},
    'bert-base-german-dbmdz-uncased': {'do_lower_case': True},
    'TurkuNLP/bert-base-finnish-cased-v1': {'do_lower_case': False},
    'TurkuNLP/bert-base-finnish-uncased-v1': {'do_lower_case': True},
    'wietsedv/bert-base-dutch-cased': {'do_lower_case': False},
}



class     _UpperCAmelCase   (   _UpperCamelCase   ):

  """simple docstring"""


  a_      =			VOCAB_FILES_NAMES
  a_      =			PRETRAINED_VOCAB_FILES_MAP
  a_      =			PRETRAINED_INIT_CONFIGURATION
  a_      =			PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  a_      =			BertTokenizer






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

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

     __lowerCAmelCase							     =     do_lower_case






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








_snake_case  :   List[str]						   =  {
    'meter': 'm',
    'kilometer': 'km',
    'megametre': 'Mm',
    'gigametre': 'Gm',
    'terametre': 'Tm',
    'petametre': 'Pm',
    'exametre': 'Em',
    'zettametre': 'Zm',
    'yottametre': 'Ym',
}
# Exponent of the factor(meter)
_snake_case  :   List[Any]						   =  {
    'm': 0,
    'km': 3,
    'Mm': 6,
    'Gm': 9,
    'Tm': 12,
    'Pm': 15,
    'Em': 18,
    'Zm': 21,
    'Ym': 24,
}

def   a_   (			lowerCAmelCase_				:      float,     lowerCAmelCase_				:      str,     lowerCAmelCase_				:      str     ):
   __lowerCAmelCase							     =     from_type.lower().strip('s'     )
   __lowerCAmelCase							     =     to_type.lower().strip('s'     )

   __lowerCAmelCase							     =     UNIT_SYMBOL.get(lowerCAmelCase_,     lowerCAmelCase_     )
   __lowerCAmelCase							     =     UNIT_SYMBOL.get(lowerCAmelCase_,     lowerCAmelCase_     )

   if from_sanitized not in METRIC_CONVERSION:
      __lowerCAmelCase							     =     (
          F"""Invalid 'from_type' value: {from_type!r}.\n"""
          F"""Conversion abbreviations are: {", ".join(lowerCAmelCase_     )}"""
      )
      raise ValueError(lowerCAmelCase_     )
   if to_sanitized not in METRIC_CONVERSION:
      __lowerCAmelCase							     =     (
          F"""Invalid 'to_type' value: {to_type!r}.\n"""
          F"""Conversion abbreviations are: {", ".join(lowerCAmelCase_     )}"""
      )
      raise ValueError(lowerCAmelCase_     )
   __lowerCAmelCase							     =     METRIC_CONVERSION[from_sanitized]
   __lowerCAmelCase							     =     METRIC_CONVERSION[to_sanitized]
   __lowerCAmelCase							     =     1

   if from_exponent > to_exponent:
      __lowerCAmelCase							     =     from_exponent - to_exponent
   else:
      __lowerCAmelCase							     =     -(to_exponent - from_exponent)

   return value * pow(10,     lowerCAmelCase_     )


if __name__ == "__main__":
     from doctest import testmod

     testmod()

