




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


lowercase__   :    str 					=      logging.get_logger(__name__)

lowercase__   :    List[str] 					=      {"""vocab_file""": """vocab.json""", """merges_file""": """merges.txt""", """tokenizer_file""": """tokenizer.json"""}

lowercase__   :    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"""
        ),
    },
}

lowercase__   :    Dict 					=      {
    """openai/clip-vit-base-patch32""": 77,
}




class     a__ (      a_   ):
     a	:    List[Any]	      =			VOCAB_FILES_NAMES
     a	:    str	      =			PRETRAINED_VOCAB_FILES_MAP
     a	:    List[Any]	      =			PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
     a	:    Tuple	      =			['input_ids', 'attention_mask']
     a	:    List[str]	      =			CLIPTokenizer







     def __init__(			self						,	A=None						,	A=None						,	A=None						,	A="<|endoftext|>"						,	A="<|startoftext|>"						,	A="<|endoftext|>"						,	A="<|endoftext|>"						,	**A						,	)						->					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     lowerCAmelCase_       (			self				)						->					int:



          '''simple docstring'''



          a											=   self.backend_tokenizer.decode

          def new_decode_method(*A						,	**A				):
               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     lowerCAmelCase_       (			self						,	A						,	A = 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     lowerCAmelCase_       (			self						,	A						,	A = 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     lowerCAmelCase_       (			self						,	A						,	A = None				)						->					Tuple[str]:



          '''simple docstring'''



          a											=   self._tokenizer.model.save(_snake_case						,	name=_snake_case				)
          return tuple(_snake_case				)







from dataclasses import dataclass
from typing import List, Optional, Union

import numpy as np
import PIL

from ...utils import BaseOutput, is_invisible_watermark_available, is_torch_available, is_transformers_available




@dataclass
class     a__ (      UpperCamelCase__   ):
     a	:    Union[List[PIL.Image.Image], np.ndarray]


if is_transformers_available() and is_torch_available() and is_invisible_watermark_available():
   from .pipeline_stable_diffusion_xl import StableDiffusionXLPipeline
   from .pipeline_stable_diffusion_xl_imgaimg import StableDiffusionXLImgaImgPipeline

