


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


A      = logging.get_logger(__name__)

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

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

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

A      = {
    "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     lowercase__  (					__SCREAMING_SNAKE_CASE		):
  A__=  VOCAB_FILES_NAMES
  A__=  PRETRAINED_VOCAB_FILES_MAP
  A__=  PRETRAINED_INIT_CONFIGURATION
  A__=  PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  A__=  BertTokenizer






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




         """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		,						)

         UpperCAmelCase__										=     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
         ):
                UpperCAmelCase__										=     getattr(_lowercase		,						normalizer_state.pop("type" ) )
                UpperCAmelCase__										=     do_lower_case
                UpperCAmelCase__										=     strip_accents
                UpperCAmelCase__										=     tokenize_chinese_chars
                UpperCAmelCase__										=     normalizer_class(**_lowercase )

         UpperCAmelCase__										=     do_lower_case






  def 			_UpperCAmelCase  (					self      :					Dict		,						_lowercase      :					List[str]		,						_lowercase      :					Any=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 			_UpperCAmelCase  (					self      :					Any		,						_lowercase      :					List[int]		,						_lowercase      :					Optional[List[int]] = 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 			_UpperCAmelCase  (					self      :					Dict		,						_lowercase      :					str		,						_lowercase      :					Optional[str] = None ):




         """simple docstring"""







         UpperCAmelCase__										=     self._tokenizer.model.save(_lowercase		,						name=_lowercase )
         return tuple(_lowercase )









from __future__ import annotations





def __UpperCAmelCase       (		__A ,						__A ,						__A ,						)						->					tuple:



       '''simple docstring'''





       if (electron_conc, hole_conc, intrinsic_conc).count(0			) != 1:
              raise ValueError("You cannot supply more or less than 2 values"			)
       elif electron_conc < 0:
              raise ValueError("Electron concentration cannot be negative in a semiconductor"			)
       elif hole_conc < 0:
              raise ValueError("Hole concentration cannot be negative in a semiconductor"			)
       elif intrinsic_conc < 0:
              raise ValueError(
                  "Intrinsic concentration cannot be negative in a semiconductor"			)
       elif electron_conc == 0:
              return (
                  "electron_conc",
                  intrinsic_conc**2 / hole_conc,
              )
       elif hole_conc == 0:
              return (
                  "hole_conc",
                  intrinsic_conc**2 / electron_conc,
              )
       elif intrinsic_conc == 0:
              return (
                  "intrinsic_conc",
                  (electron_conc * hole_conc) ** 0.5,
              )
       else:
              return (-1, -1)


if __name__ == "__main__":
    import doctest

    doctest.testmod()





