

from typing import List, Optional, Tuple

from tokenizers import pre_tokenizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_clip import CLIPTokenizer


UpperCamelCase__					: List[str]								=      logging.get_logger(__name__)

UpperCamelCase__					: int								=      {"vocab_file": "vocab.json", "merges_file": "merges.txt", "tokenizer_file": "tokenizer.json"}

UpperCamelCase__					: str								=      {
    "vocab_file": {
        "openai/clip-vit-base-patch32": "https://huggingface.co/openai/clip-vit-base-patch32/resolve/main/vocab.json",
    },
    "merges_file": {
        "openai/clip-vit-base-patch32": "https://huggingface.co/openai/clip-vit-base-patch32/resolve/main/merges.txt",
    },
    "tokenizer_file": {
        "openai/clip-vit-base-patch32": (
            "https://huggingface.co/openai/clip-vit-base-patch32/resolve/main/tokenizer.json"
        ),
    },
}

UpperCamelCase__					: Optional[Any]								=      {
    "openai/clip-vit-base-patch32": 77,
}



class  __snake_case					(      lowerCAmelCase__    ):
  __lowerCAmelCase       :		Any  	=					VOCAB_FILES_NAMES
  __lowerCAmelCase       :		str  	=					PRETRAINED_VOCAB_FILES_MAP
  __lowerCAmelCase       :		List[Any]  	=					PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  __lowerCAmelCase       :		Dict  	=					['input_ids', 'attention_mask']
  __lowerCAmelCase       :		List[Any]  	=					CLIPTokenizer

  def __init__(   self  ,						_A=None  ,						_A=None  ,						_A=None  ,						_A="<|endoftext|>"  ,						_A="<|startoftext|>"  ,						_A="<|endoftext|>"  ,						_A="<|endoftext|>"  ,						**_A  ,						):
      super().__init__(
          _A  ,						_A  ,						tokenizer_file=_A  ,						unk_token=_A  ,						bos_token=_A  ,						eos_token=_A  ,						pad_token=_A  ,						**_A  ,						)

      if not isinstance(self.backend_tokenizer.pre_tokenizer  ,						pre_tokenizers.Sequence):
          raise ValueError(
              'The `backend_tokenizer` provided does not match the expected format. The CLIP tokenizer has been'
              ' heavily modified from transformers version 4.17.0. You need to convert the tokenizer you are using'
              ' to be compatible with this version.The easiest way to do so is'
              ' `CLIPTokenizerFast.from_pretrained("path_to_local_folder_or_hub_repo, from_slow=True)`. If you want'
              ' to use your existing tokenizer, you will have to revert to a version prior to 4.17.0 of'
              ' transformers.')

      self._wrap_decode_method_backend_tokenizer()

  def   lowerCAmelCase__       (   self):
      SCREAMING_SNAKE_CASE_													=  self.backend_tokenizer.decode

      def new_decode_method(*_A  ,						**_A):
          SCREAMING_SNAKE_CASE_													=  orig_decode_method(*_A  ,						**_A)
          SCREAMING_SNAKE_CASE_													=  text.replace(self.backend_tokenizer.model.end_of_word_suffix  ,						' ').strip()
          return text

      SCREAMING_SNAKE_CASE_													=  new_decode_method

  def   lowerCAmelCase__       (   self  ,						_A  ,						_A = None):
      SCREAMING_SNAKE_CASE_													=  [self.bos_token_id]
      SCREAMING_SNAKE_CASE_													=  [self.eos_token_id]

      if token_ids_a is None:
          return bos_token + token_ids_a + eos_token
      return bos_token + token_ids_a + eos_token + eos_token + token_ids_a + eos_token

  def   lowerCAmelCase__       (   self  ,						_A  ,						_A = None):
      SCREAMING_SNAKE_CASE_													=  [self.bos_token_id]
      SCREAMING_SNAKE_CASE_													=  [self.eos_token_id]

      if token_ids_a is None:
          return len(bos_token + token_ids_a + eos_token) * [0]
      return len(bos_token + token_ids_a + eos_token + eos_token + token_ids_a + eos_token) * [0]


  def   lowerCAmelCase__       (   self  ,						_A  ,						_A = None):
      SCREAMING_SNAKE_CASE_													=  self._tokenizer.model.save(_A  ,						name=_A)
      return tuple(_A)





def    _UpperCAmelCase    (					_SCREAMING_SNAKE_CASE   :						int	,				_SCREAMING_SNAKE_CASE   :						int	,				_SCREAMING_SNAKE_CASE   :						int    ):





    """simple docstring"""


    if power < 0:
        return -1
    base %= mod
    SCREAMING_SNAKE_CASE_													=  1

    while power > 0:
        if power & 1:
            SCREAMING_SNAKE_CASE_													=  (result * base) % mod
        SCREAMING_SNAKE_CASE_													=  power >> 1
        SCREAMING_SNAKE_CASE_													=  (base * base) % mod

    return result


def    _UpperCAmelCase    (					):





    """simple docstring"""


    print(modular_exponential(3	,				200	,				13    )    )


if __name__ == "__main__":
       import doctest

       doctest.testmod()

       main()


