


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


_a      :      Dict       				=      logging.get_logger(__name__)

_a      :      Tuple       				=      {'vocab_file': 'vocab.json', 'merges_file': 'merges.txt', 'tokenizer_file': 'tokenizer.json'}

_a      :      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'
        ),
    },
}

_a      :      Optional[int]       				=      {
    'openai/clip-vit-base-patch32': 77,
}




class  _lowercase   (  lowercase_       ):
   _SCREAMING_SNAKE_CASE     :     str									=  VOCAB_FILES_NAMES
   _SCREAMING_SNAKE_CASE     :     List[Any]									=  PRETRAINED_VOCAB_FILES_MAP
   _SCREAMING_SNAKE_CASE     :     Optional[int]									=  PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
   _SCREAMING_SNAKE_CASE     :     Dict									=  ["""input_ids""", """attention_mask"""]
   _SCREAMING_SNAKE_CASE     :     int									=  CLIPTokenizer
   def __init__(	self					:			Any					,      SCREAMING_SNAKE_CASE_					:			Dict=None					,      SCREAMING_SNAKE_CASE_					:			List[str]=None					,      SCREAMING_SNAKE_CASE_					:			str=None					,      SCREAMING_SNAKE_CASE_					:			Any="<|endoftext|>"					,      SCREAMING_SNAKE_CASE_					:			int="<|startoftext|>"					,      SCREAMING_SNAKE_CASE_					:			Dict="<|endoftext|>"					,      SCREAMING_SNAKE_CASE_					:			Any="<|endoftext|>"					,      **SCREAMING_SNAKE_CASE_					:			List[str]					,      )   ->       str:
        super().__init__(
            SCREAMING_SNAKE_CASE_					,      SCREAMING_SNAKE_CASE_					,      tokenizer_file=SCREAMING_SNAKE_CASE_					,      unk_token=SCREAMING_SNAKE_CASE_					,      bos_token=SCREAMING_SNAKE_CASE_					,      eos_token=SCREAMING_SNAKE_CASE_					,      pad_token=SCREAMING_SNAKE_CASE_					,      **SCREAMING_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 a     (	self					:			int			)   ->       str:
        __snake_case    			=	self.backend_tokenizer.decode

        def new_decode_method(*SCREAMING_SNAKE_CASE_					:			Optional[int]					,      **SCREAMING_SNAKE_CASE_					:			List[Any]			):
             __snake_case    			=	orig_decode_method(*SCREAMING_SNAKE_CASE_					,      **SCREAMING_SNAKE_CASE_			)
             __snake_case    			=	text.replace(self.backend_tokenizer.model.end_of_word_suffix					,      ' '			).strip()
             return text

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








'''simple docstring'''




def      _a		(lowercase__ :      int	) -> int:






     """simple docstring"""
     return 1 if input_a == 0 else 0





def      _a		() -> None:






     """simple docstring"""
     assert not_gate(0	) == 1
     assert not_gate(1	) == 0


if __name__ == "__main__":
       print(not_gate(0))
       print(not_gate(1))




