code: 
  
  
  
  
  """simple docstring"""
  
  
  
  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
  
  
  SCREAMING_SNAKE_CASE       = logging.get_logger(__name__)
  
  SCREAMING_SNAKE_CASE       = {"vocab_file": "vocab.json", "merges_file": "merges.txt", "tokenizer_file": "tokenizer.json"}
  
  SCREAMING_SNAKE_CASE       = {
      "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"
          ),
      },
  }
  
  SCREAMING_SNAKE_CASE       = {
      "openai/clip-vit-base-patch32": 77,
  }
  
  
  
  
  class 			UpperCAmelCase_						(		A_							):
      lowercase__		      =   VOCAB_FILES_NAMES
      lowercase__		      =   PRETRAINED_VOCAB_FILES_MAP
      lowercase__		      =   PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
      lowercase__		      =   ['''input_ids''', '''attention_mask''']
      lowercase__		      =   CLIPTokenizer
  
  
  
  
      def __init__(					self		: int			,				snake_case_		: Optional[Any]=None			,				snake_case_		: int=None			,				snake_case_		: Union[str, Any]=None			,				snake_case_		: str="<|endoftext|>"			,				snake_case_		: List[str]="<|startoftext|>"			,				snake_case_		: str="<|endoftext|>"			,				snake_case_		: Dict="<|endoftext|>"			,				**snake_case_		: int			,				)   ->							Union[str, Any]:
  
  
  
  
       '''simple docstring'''
  
       super().__init__(
           snake_case_			,				snake_case_			,				tokenizer_file=snake_case_			,				unk_token=snake_case_			,				bos_token=snake_case_			,				eos_token=snake_case_			,				pad_token=snake_case_			,				**snake_case_			,				)
  
       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 							__magic_name__							(					self		: str   )   ->							str:
  
  
  
  
       '''simple docstring'''
  
       A__ =       self.backend_tokenizer.decode
  
       def new_decode_method(*snake_case_		: Any			,				**snake_case_		: Optional[int]   ):
        A__ =       orig_decode_method(*snake_case_			,				**snake_case_   )
        A__ =       text.replace(self.backend_tokenizer.model.end_of_word_suffix			,				" "   ).strip()
        return text
  
       A__ =       new_decode_method
  
  
  
  
      def 							__magic_name__							(					self		: Union[str, Any]			,				snake_case_		: List[int]			,				snake_case_		: Optional[List[int]] = None   )   ->							List[int]:
  
  
  
  
       '''simple docstring'''
  
       A__ =       [self.bos_token_id]
       A__ =       [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 							__magic_name__							(					self		: Tuple			,				snake_case_		: List[int]			,				snake_case_		: Optional[List[int]] = None   )   ->							List[int]:
  
  
  
  
       '''simple docstring'''
  
       A__ =       [self.bos_token_id]
       A__ =       [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 							__magic_name__							(					self		: int			,				snake_case_		: str			,				snake_case_		: Optional[str] = None   )   ->							Tuple[str]:
  
  
  
  
       '''simple docstring'''
  
       A__ =       self._tokenizer.model.save(snake_case_			,				name=snake_case_   )
       return tuple(snake_case_   )
  
  
  
  
  
  
style_context: 
  
  
  
  
  """simple docstring"""
  
  
  
  from transformers import PretrainedConfig
  
  
  
  
  class 			UpperCAmelCase_						(		A_							):
      lowercase__		      =   '''custom'''
  
  
  
  
      def __init__(					self		: Any			,				snake_case_		: List[Any]=1			,				**snake_case_		: Any   )   ->							str:
  
  
  
  
       '''simple docstring'''
  
       A__ =       attribute
       super().__init__(**snake_case_   )
  
  
  
  
  
  
  class 			UpperCAmelCase_						(		A_							):
      lowercase__		      =   '''custom'''
  
  
  
  
      def __init__(					self		: Any			,				snake_case_		: Tuple=1			,				**snake_case_		: Dict   )   ->							Any:
  
  
  
  
       '''simple docstring'''
  
       A__ =       attribute
  
  
  
  
  
  