


"""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_distilbert import DistilBertTokenizer


__lowercase    =				logging.get_logger(__name__)

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

__lowercase    =				{
    """vocab_file""": {
        """distilbert-base-uncased""": """https://huggingface.co/distilbert-base-uncased/resolve/main/vocab.txt""",
        """distilbert-base-uncased-distilled-squad""": (
            """https://huggingface.co/distilbert-base-uncased-distilled-squad/resolve/main/vocab.txt"""
        ),
        """distilbert-base-cased""": """https://huggingface.co/distilbert-base-cased/resolve/main/vocab.txt""",
        """distilbert-base-cased-distilled-squad""": (
            """https://huggingface.co/distilbert-base-cased-distilled-squad/resolve/main/vocab.txt"""
        ),
        """distilbert-base-german-cased""": """https://huggingface.co/distilbert-base-german-cased/resolve/main/vocab.txt""",
        """distilbert-base-multilingual-cased""": (
            """https://huggingface.co/distilbert-base-multilingual-cased/resolve/main/vocab.txt"""
        ),
    },
    """tokenizer_file""": {
        """distilbert-base-uncased""": """https://huggingface.co/distilbert-base-uncased/resolve/main/tokenizer.json""",
        """distilbert-base-uncased-distilled-squad""": (
            """https://huggingface.co/distilbert-base-uncased-distilled-squad/resolve/main/tokenizer.json"""
        ),
        """distilbert-base-cased""": """https://huggingface.co/distilbert-base-cased/resolve/main/tokenizer.json""",
        """distilbert-base-cased-distilled-squad""": (
            """https://huggingface.co/distilbert-base-cased-distilled-squad/resolve/main/tokenizer.json"""
        ),
        """distilbert-base-german-cased""": (
            """https://huggingface.co/distilbert-base-german-cased/resolve/main/tokenizer.json"""
        ),
        """distilbert-base-multilingual-cased""": (
            """https://huggingface.co/distilbert-base-multilingual-cased/resolve/main/tokenizer.json"""
        ),
    },
}

__lowercase    =				{
    """distilbert-base-uncased""": 512,
    """distilbert-base-uncased-distilled-squad""": 512,
    """distilbert-base-cased""": 512,
    """distilbert-base-cased-distilled-squad""": 512,
    """distilbert-base-german-cased""": 512,
    """distilbert-base-multilingual-cased""": 512,
}


__lowercase    =				{
    """distilbert-base-uncased""": {"""do_lower_case""": True},
    """distilbert-base-uncased-distilled-squad""": {"""do_lower_case""": True},
    """distilbert-base-cased""": {"""do_lower_case""": False},
    """distilbert-base-cased-distilled-squad""": {"""do_lower_case""": False},
    """distilbert-base-german-cased""": {"""do_lower_case""": False},
    """distilbert-base-multilingual-cased""": {"""do_lower_case""": False},
}






class 						_A  (  _a  ):







    """simple docstring"""




    UpperCAmelCase	:							Dict     =	VOCAB_FILES_NAMES
    UpperCAmelCase	:							Union[str, Any]     =	PRETRAINED_VOCAB_FILES_MAP
    UpperCAmelCase	:							List[str]     =	PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
    UpperCAmelCase	:							str     =	PRETRAINED_INIT_CONFIGURATION
    UpperCAmelCase	:							Optional[Any]     =	["""input_ids""", """attention_mask"""]
    UpperCAmelCase	:							List[str]     =	DistilBertTokenizer






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

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

      a						:		Optional[int]											=      do_lower_case






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










"""simple docstring"""







import sys
import turtle


def 					lowercase      (    A_  ,       A_	)->				tuple[float, float]:
  '''simple docstring'''







  return (pa[0] + pa[0]) / 2, (pa[1] + pa[1]) / 2


def 					lowercase      (    A_  ,       A_  ,       A_  ,       A_  ,       )->				None:
  '''simple docstring'''







  my_pen.up()
  my_pen.goto(vertexa[0]  ,       vertexa[1]	)
  my_pen.down()
  my_pen.goto(vertexa[0]  ,       vertexa[1]	)
  my_pen.goto(vertexa[0]  ,       vertexa[1]	)
  my_pen.goto(vertexa[0]  ,       vertexa[1]	)

  if depth == 0:
    return

  triangle(A_  ,       get_mid(A_  ,       A_	)  ,       get_mid(A_  ,       A_	)  ,       depth - 1	)
  triangle(A_  ,       get_mid(A_  ,       A_	)  ,       get_mid(A_  ,       A_	)  ,       depth - 1	)
  triangle(A_  ,       get_mid(A_  ,       A_	)  ,       get_mid(A_  ,       A_	)  ,       depth - 1	)


if __name__ == "__main__":
 if len(sys.argv) != 2:
  raise ValueError(
      """Correct format for using this script: """
      """python fractals.py <int:depth_for_fractal>"""
  )
 __lowercase    =				turtle.Turtle()
 my_pen.ht()
 my_pen.speed(5)
 my_pen.pencolor("""red""")

 __lowercase    =				[(-175, -125), (0, 175), (175, -125)]  # vertices of triangle
 triangle(vertices[0], vertices[1], vertices[2], int(sys.argv[1]))






