


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


lowerCAmelCase       =							logging.get_logger(__name__)

lowerCAmelCase       =							{'vocab_file': 'vocab.txt', 'tokenizer_file': 'tokenizer.json'}

lowerCAmelCase       =							{
    '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'
        ),
    },
}

lowerCAmelCase       =							{
    '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,
}

lowerCAmelCase       =							{
    '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							(			UpperCamelCase__			):
							_lowercase	:			Union[str, Any]        = VOCAB_FILES_NAMES
							_lowercase	:			Dict        = PRETRAINED_VOCAB_FILES_MAP
							_lowercase	:			int        = PRETRAINED_INIT_CONFIGURATION
							_lowercase	:			str        = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
							_lowercase	:			List[str]        = BertTokenizer

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





									"""simple docstring"""







									super().__init__(
									    UpperCamelCase_    ,						tokenizer_file=UpperCamelCase_    ,						do_lower_case=UpperCamelCase_    ,						unk_token=UpperCamelCase_    ,						sep_token=UpperCamelCase_    ,						pad_token=UpperCamelCase_    ,						cls_token=UpperCamelCase_    ,						mask_token=UpperCamelCase_    ,						tokenize_chinese_chars=UpperCamelCase_    ,						strip_accents=UpperCamelCase_    ,						**UpperCamelCase_    ,						)

									lowercase__            =      json.loads(self.backend_tokenizer.normalizer.__getstate__()							)
									if (
									    normalizer_state.get('''lowercase'''    ,						UpperCamelCase_							) != do_lower_case
									    or normalizer_state.get('''strip_accents'''    ,						UpperCamelCase_							) != strip_accents
									    or normalizer_state.get('''handle_chinese_chars'''    ,						UpperCamelCase_							) != tokenize_chinese_chars
									):
											lowercase__            =      getattr(UpperCamelCase_    ,						normalizer_state.pop('''type'''							)							)
											lowercase__            =      do_lower_case
											lowercase__            =      strip_accents
											lowercase__            =      tokenize_chinese_chars
											lowercase__            =      normalizer_class(**UpperCamelCase_							)

									lowercase__            =      do_lower_case

							def       lowerCamelCase_ (							self:	List[Any]    ,						UpperCamelCase_:	List[Any]    ,						UpperCamelCase_:	Optional[int]=None							)			->   int:





									"""simple docstring"""







									lowercase__            =      [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:	int    ,						UpperCamelCase_:	List[int]    ,						UpperCamelCase_:	Optional[List[int]] = None							)			->   List[int]:





									"""simple docstring"""







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





									"""simple docstring"""







									lowercase__            =      self._tokenizer.model.save(UpperCamelCase_    ,						name=UpperCamelCase_							)
									return tuple(UpperCamelCase_							)






from __future__ import annotations

from collections.abc import Iterator


class        _a							:

							def __init__(							self:	List[str]    ,						UpperCamelCase_:	int							)			->   None:





									"""simple docstring"""







									lowercase__            =      value
									lowercase__            =      None
									lowercase__            =      None


class        _a							:

							def __init__(							self:	Union[str, Any]    ,						UpperCamelCase_:	Node							)			->   None:





									"""simple docstring"""







									lowercase__            =      tree

							def       lowerCamelCase_ (							self:	Any    ,						UpperCamelCase_:	Node | None							)			->   int:





									"""simple docstring"""







									if node is None:
											return 0
									return node.value + (
									    self.depth_first_search(node.left							) + self.depth_first_search(node.right							)
									)


							def __iter__(							self:	List[str]							)			->   Iterator[int]:





									"""simple docstring"""







									yield self.depth_first_search(self.tree							)


if __name__ == "__main__":
			import doctest

			doctest.testmod()


