






'''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_bert import BertTokenizer


UpperCamelCase      					=logging.get_logger(__name__)

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

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

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

UpperCamelCase      					={
    "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      A     (   SCREAMING_SNAKE_CASE__    ):






 """simple docstring"""





 __a      :    List[str]			  =    VOCAB_FILES_NAMES
 __a      :    Tuple			  =    PRETRAINED_VOCAB_FILES_MAP
 __a      :    Optional[Any]			  =    PRETRAINED_INIT_CONFIGURATION
 __a      :    Optional[int]			  =    PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 __a      :    int			  =    BertTokenizer
 def __init__(				self      ,  __lowerCAmelCase=None      ,  __lowerCAmelCase=None      ,  __lowerCAmelCase=True      ,  __lowerCAmelCase="[UNK]"      ,  __lowerCAmelCase="[SEP]"      ,  __lowerCAmelCase="[PAD]"      ,  __lowerCAmelCase="[CLS]"      ,  __lowerCAmelCase="[MASK]"      ,  __lowerCAmelCase=True      ,  __lowerCAmelCase=None      ,  **__lowerCAmelCase      ,  ):
       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      ,  )

       UpperCamelCase_					: Optional[int]            =				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
       ):
             UpperCamelCase_					: List[str]            =				getattr(__lowerCAmelCase      ,  normalizer_state.pop("""type"""			)			)
             UpperCamelCase_					: List[Any]            =				do_lower_case
             UpperCamelCase_					: str            =				strip_accents
             UpperCamelCase_					: List[str]            =				tokenize_chinese_chars
             UpperCamelCase_					: Union[str, Any]            =				normalizer_class(**__lowerCAmelCase			)

       UpperCamelCase_					: Any            =				do_lower_case
 def 	_UpperCAmelCase							(				self      ,  __lowerCAmelCase      ,  __lowerCAmelCase=None			):
       UpperCamelCase_					: Optional[Any]            =				[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      ,  __lowerCAmelCase      ,  __lowerCAmelCase = None			):
       UpperCamelCase_					: Union[str, Any]            =				[self.sep_token_id]
       UpperCamelCase_					: Optional[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 	_UpperCAmelCase							(				self      ,  __lowerCAmelCase      ,  __lowerCAmelCase = None			):
       UpperCamelCase_					: List[Any]            =				self._tokenizer.model.save(__lowerCAmelCase      ,  name=__lowerCAmelCase			)
       return tuple(__lowerCAmelCase			)














'''simple docstring'''

from __future__ import annotations

from math import pi, sqrt



def 				snake_case       (  a_				:			float     , a_				:			float						)							->					tuple:





      """simple docstring"""

      if inductance <= 0:
            raise ValueError("""Inductance cannot be 0 or negative"""						)

      elif capacitance <= 0:
            raise ValueError("""Capacitance cannot be 0 or negative"""						)

      else:
            return (
                "Resonant frequency",
                float(1 / (2 * pi * (sqrt(inductance * capacitance						)))						),
            )


if __name__ == "__main__":
      import doctest

      doctest.testmod()






