

"""simple docstring"""






from __future__ import annotations

from sys import maxsize
from typing import Generic, TypeVar

__lowerCamelCase										=		TypeVar("T")





def 	lowercase      (   __UpperCamelCase						) ->      int:
 return (position - 1) // 2





def 	lowercase      (   __UpperCamelCase						) ->      int:
 return (2 * position) + 1





def 	lowercase      (   __UpperCamelCase						) ->      int:
 return (2 * position) + 2
class        _lowercase					(     Generic[T]     ):







     def __init__(      self       ):
      __magic_name__     =      []
      __magic_name__     =      {}
      __magic_name__     =      0







     def __len__(      self       ):
      return self.elements







     def __repr__(      self       ):
      return str(self.heap       )







     def 	lowerCAmelCase__    (      self       ):
      # Check if the priority queue is empty
      return self.elements == 0







     def 	lowerCAmelCase__    (      self ,						UpperCamelCase_ ,						UpperCamelCase_       ):
      # Add an element with given priority to the queue
      self.heap.append((elem, weight)       )
      __magic_name__     =      self.elements
      self.elements += 1
      self._bubble_up(UpperCamelCase_       )







     def 	lowerCAmelCase__    (      self       ):
      # Remove and return the element with lowest weight (highest priority)
      if self.elements > 1:
       self._swap_nodes(0 ,						self.elements - 1       )
      __magic_name__   ,						__magic_name__     =      self.heap.pop()
      del self.position_map[elem]
      self.elements -= 1
      if self.elements > 0:
       __magic_name__   ,						__magic_name__     =      self.heap[0]
       self._bubble_down(UpperCamelCase_       )
      return elem







     def 	lowerCAmelCase__    (      self ,						UpperCamelCase_ ,						UpperCamelCase_       ):
      # Update the weight of the given key
      __magic_name__     =      self.position_map[elem]
      __magic_name__     =      (elem, weight)
      if position > 0:
       __magic_name__     =      get_parent_position(UpperCamelCase_       )
       __magic_name__   ,						__magic_name__     =      self.heap[parent_position]
       if parent_weight > weight:
        self._bubble_up(UpperCamelCase_       )
       else:
        self._bubble_down(UpperCamelCase_       )
      else:
       self._bubble_down(UpperCamelCase_       )







     def 	lowerCAmelCase__    (      self ,						UpperCamelCase_       ):
      # Place a node at the proper position (upward movement) [to be used internally
      # only]
      __magic_name__     =      self.position_map[elem]
      if curr_pos == 0:
       return None
      __magic_name__     =      get_parent_position(UpperCamelCase_       )
      __magic_name__   ,						__magic_name__     =      self.heap[curr_pos]
      __magic_name__   ,						__magic_name__     =      self.heap[parent_position]
      if parent_weight > weight:
       self._swap_nodes(UpperCamelCase_ ,						UpperCamelCase_       )
       return self._bubble_up(UpperCamelCase_       )
      return None







     def 	lowerCAmelCase__    (      self ,						UpperCamelCase_       ):
      # Place a node at the proper position (downward movement) [to be used
      # internally only]
      __magic_name__     =      self.position_map[elem]
      __magic_name__   ,						__magic_name__     =      self.heap[curr_pos]
      __magic_name__     =      get_child_left_position(UpperCamelCase_       )
      __magic_name__     =      get_child_right_position(UpperCamelCase_       )
      if child_left_position < self.elements and child_right_position < self.elements:
       __magic_name__   ,						__magic_name__     =      self.heap[child_left_position]
       __magic_name__   ,						__magic_name__     =      self.heap[child_right_position]
       if child_right_weight < child_left_weight and child_right_weight < weight:
        self._swap_nodes(UpperCamelCase_ ,						UpperCamelCase_       )
        return self._bubble_down(UpperCamelCase_       )
      if child_left_position < self.elements:
       __magic_name__   ,						__magic_name__     =      self.heap[child_left_position]
       if child_left_weight < weight:
        self._swap_nodes(UpperCamelCase_ ,						UpperCamelCase_       )
        return self._bubble_down(UpperCamelCase_       )
      else:
       return None
      if child_right_position < self.elements:
       __magic_name__   ,						__magic_name__     =      self.heap[child_right_position]
       if child_right_weight < weight:
        self._swap_nodes(UpperCamelCase_ ,						UpperCamelCase_       )
        return self._bubble_down(UpperCamelCase_       )
      return None







     def 	lowerCAmelCase__    (      self ,						UpperCamelCase_ ,						UpperCamelCase_       ):
      # Swap the nodes at the given positions
      __magic_name__     =      self.heap[nodea_pos][0]
      __magic_name__     =      self.heap[nodea_pos][0]
      __magic_name__   ,						__magic_name__     =      (
          self.heap[nodea_pos],
          self.heap[nodea_pos],
      )
      __magic_name__     =      nodea_pos
      __magic_name__     =      nodea_pos


class        _lowercase					(     Generic[T]     ):







     def __init__(      self       ):
      __magic_name__     =      {}
      __magic_name__     =      0







     def __repr__(      self       ):
      return str(self.connections       )







     def __len__(      self       ):
      return self.nodes







     def 	lowerCAmelCase__    (      self ,						UpperCamelCase_       ):
      # Add a node in the graph if it is not in the graph
      if node not in self.connections:
       __magic_name__     =      {}
       self.nodes += 1







     def 	lowerCAmelCase__    (      self ,						UpperCamelCase_ ,						UpperCamelCase_ ,						UpperCamelCase_       ):
      # Add an edge between 2 nodes in the graph
      self.add_node(UpperCamelCase_       )
      self.add_node(UpperCamelCase_       )
      __magic_name__     =      weight
      __magic_name__     =      weight





def 	lowercase      (   __UpperCamelCase      ,   ) ->      tuple[dict[T, int], dict[T, T | None]]:
 __magic_name__     =      {node: maxsize for node in graph.connections}
 __magic_name__     =      {node: None for node in graph.connections}

 __magic_name__     =      MinPriorityQueue()
 for node, weight in dist.items():
  priority_queue.push(__UpperCamelCase      ,   __UpperCamelCase						)

 if priority_queue.is_empty():
  return dist, parent

 # initialization
 __magic_name__     =      priority_queue.extract_min()
 __magic_name__     =      0
 for neighbour in graph.connections[node]:
  if dist[neighbour] > dist[node] + graph.connections[node][neighbour]:
   __magic_name__     =      dist[node] + graph.connections[node][neighbour]
   priority_queue.update_key(__UpperCamelCase      ,   dist[neighbour]						)
   __magic_name__     =      node

    # running prim's algorithm
 while not priority_queue.is_empty():
  __magic_name__     =      priority_queue.extract_min()
  for neighbour in graph.connections[node]:
   if dist[neighbour] > dist[node] + graph.connections[node][neighbour]:
    __magic_name__     =      dist[node] + graph.connections[node][neighbour]
    priority_queue.update_key(__UpperCamelCase      ,   dist[neighbour]						)
    __magic_name__     =      node
 return dist, parent




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


__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": 5_12,
    "bert-large-uncased": 5_12,
    "bert-base-cased": 5_12,
    "bert-large-cased": 5_12,
    "bert-base-multilingual-uncased": 5_12,
    "bert-base-multilingual-cased": 5_12,
    "bert-base-chinese": 5_12,
    "bert-base-german-cased": 5_12,
    "bert-large-uncased-whole-word-masking": 5_12,
    "bert-large-cased-whole-word-masking": 5_12,
    "bert-large-uncased-whole-word-masking-finetuned-squad": 5_12,
    "bert-large-cased-whole-word-masking-finetuned-squad": 5_12,
    "bert-base-cased-finetuned-mrpc": 5_12,
    "bert-base-german-dbmdz-cased": 5_12,
    "bert-base-german-dbmdz-uncased": 5_12,
    "TurkuNLP/bert-base-finnish-cased-v1": 5_12,
    "TurkuNLP/bert-base-finnish-uncased-v1": 5_12,
    "wietsedv/bert-base-dutch-cased": 5_12,
}

__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        _lowercase					(     __UpperCAmelCase     ):
     _lowerCamelCase     =       VOCAB_FILES_NAMES
     _lowerCamelCase     =       PRETRAINED_VOCAB_FILES_MAP
     _lowerCamelCase     =       PRETRAINED_INIT_CONFIGURATION
     _lowerCamelCase     =       PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
     _lowerCamelCase     =       BertTokenizer







     def __init__(      self ,						UpperCamelCase_=None ,						UpperCamelCase_=None ,						UpperCamelCase_=True ,						UpperCamelCase_="[UNK]" ,						UpperCamelCase_="[SEP]" ,						UpperCamelCase_="[PAD]" ,						UpperCamelCase_="[CLS]" ,						UpperCamelCase_="[MASK]" ,						UpperCamelCase_=True ,						UpperCamelCase_=None ,						**UpperCamelCase_ ,						):
      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_ ,						)

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

      __magic_name__     =      do_lower_case







     def 	lowerCAmelCase__    (      self ,						UpperCamelCase_ ,						UpperCamelCase_=None       ):
      __magic_name__     =      [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 ,						UpperCamelCase_ ,						UpperCamelCase_ = None       ):
      __magic_name__     =      [self.sep_token_id]
      __magic_name__     =      [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 ,						UpperCamelCase_ ,						UpperCamelCase_ = None       ):
      __magic_name__     =      self._tokenizer.model.save(UpperCamelCase_ ,						name=UpperCamelCase_       )
      return tuple(UpperCamelCase_       )

