




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


lowerCAmelCase__						=	logging.get_logger(__name__)

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

lowerCAmelCase__						=	{
    """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"""
        ),
    },
}

lowerCAmelCase__						=	{
    """openai/clip-vit-base-patch32""": 7_7,
}

class    a__  (   lowerCamelCase__     ):
			"""simple docstring"""







			__lowerCamelCase	    =    VOCAB_FILES_NAMES
			__lowerCamelCase	    =    PRETRAINED_VOCAB_FILES_MAP
			__lowerCamelCase	    =    PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
			__lowerCamelCase	    =    ['input_ids', 'attention_mask']
			__lowerCamelCase	    =    CLIPTokenizer


			def __init__(      self , lowercase=None , lowercase=None , lowercase=None , lowercase="<|endoftext|>" , lowercase="<|startoftext|>" , lowercase="<|endoftext|>" , lowercase="<|endoftext|>" , **lowercase , )					->  Tuple:
							'''simple docstring'''






							super().__init__(
							    lowercase_ , lowercase_ , tokenizer_file=lowercase_ , unk_token=lowercase_ , bos_token=lowercase_ , eos_token=lowercase_ , pad_token=lowercase_ , **lowercase_ , )

							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        UpperCamelCase						(      self    )					->  Optional[Any]:
							'''simple docstring'''






							A__            =     self.backend_tokenizer.decode

							def new_decode_method(*lowercase , **lowercase    ):
											A__            =     orig_decode_method(*lowercase_ , **lowercase_    )
											A__            =     text.replace(self.backend_tokenizer.model.end_of_word_suffix , " "    ).strip()
											return text

							A__            =     new_decode_method


			def        UpperCamelCase						(      self , lowercase , lowercase = 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        UpperCamelCase						(      self , lowercase , lowercase = 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        UpperCamelCase						(      self , lowercase , lowercase = None    )					->  Tuple[str]:
							'''simple docstring'''






							A__            =     self._tokenizer.model.save(lowercase_ , name=lowercase_    )
							return tuple(lowercase_    )




def    lowerCAmelCase__							(		SCREAMING_SNAKE_CASE_:							list		,    SCREAMING_SNAKE_CASE_:							int		,    SCREAMING_SNAKE_CASE_:							int		,    SCREAMING_SNAKE_CASE_:							int )     -> int:




				'''simple docstring'''





				A__            =     int((lower_bound + upper_bound) // 2 )
				if array[r] == value:
								return r
				if lower_bound >= upper_bound:
								return -1
				if array[r] < value:
								return binary_search(SCREAMING_SNAKE_CASE_		,    r + 1		,    SCREAMING_SNAKE_CASE_		,    SCREAMING_SNAKE_CASE_ )
				else:
								return binary_search(SCREAMING_SNAKE_CASE_		,    SCREAMING_SNAKE_CASE_		,    r - 1		,    SCREAMING_SNAKE_CASE_ )



def    lowerCAmelCase__							(		SCREAMING_SNAKE_CASE_:							int		,    SCREAMING_SNAKE_CASE_:							list )     -> list:




				'''simple docstring'''





				A__            =     0
				if matrix[index][0] == value:
								return [index, 0]
				while index < len(SCREAMING_SNAKE_CASE_ ) and matrix[index][0] < value:
								A__            =     binary_search(matrix[index]		,    0		,    len(matrix[index] ) - 1		,    SCREAMING_SNAKE_CASE_ )
								if r != -1:
												return [index, r]
								index += 1
				return [-1, -1]


if __name__ == "__main__":
	import doctest

	doctest.testmod()

