



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						  =     logging.get_logger(__name__)

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

__UpperCAmelCase						  =     {
    '''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						  =     {
    '''openai/clip-vit-base-patch32''': 77,
}


class 	lowerCamelCase__ (		_a   ):
						_lowerCAmelCase								= VOCAB_FILES_NAMES
						_lowerCAmelCase								= PRETRAINED_VOCAB_FILES_MAP
						_lowerCAmelCase								= PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
						_lowerCAmelCase								= ['''input_ids''', '''attention_mask''']
						_lowerCAmelCase								= CLIPTokenizer


						def __init__( self						:  Optional[Any]      ,       _a						:  Tuple=None      ,       _a						:  Optional[int]=None      ,       _a						:  str=None      ,       _a						:  List[Any]="<|endoftext|>"      ,       _a						:  Union[str, Any]="<|startoftext|>"      ,       _a						:  Tuple="<|endoftext|>"      ,       _a						:  Optional[Any]="<|endoftext|>"      ,       **_a						:  Dict      ,       ):
													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						:  str			):
													a__:       List[str]											=self.backend_tokenizer.decode

													def new_decode_method(*_a						:  Any      ,       **_a						:  Dict			):
																				a__:       str											=orig_decode_method(*_a      ,       **_a			)
																				a__:       Any											=text.replace(self.backend_tokenizer.model.end_of_word_suffix      ,       " "			).strip()
																				return text

													a__:       List[str]											=new_decode_method


						def   _lowerCamelCase			( self						:  List[str]      ,       _a						:  List[int]      ,       _a						:  Optional[List[int]] = None			):
													a__:       Tuple											=[self.bos_token_id]
													a__:       List[str]											=[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						:  int      ,       _a						:  List[int]      ,       _a						:  Optional[List[int]] = None			):
													a__:       Any											=[self.bos_token_id]
													a__:       Dict											=[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						:  Optional[Any]      ,       _a						:  str      ,       _a						:  Optional[str] = None			):
													a__:       Tuple											=self._tokenizer.model.save(_a      ,       name=_a			)
													return tuple(_a			)










from ...utils import is_transformers_available
from .pipeline_latent_diffusion_superresolution import LDMSuperResolutionPipeline


if is_transformers_available():
		from .pipeline_latent_diffusion import LDMBertModel, LDMTextToImagePipeline





