





import os
import re
import warnings
from shutil import copyfile
from typing import List, Optional, Tuple

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
				from .tokenization_ta import TaTokenizer
else:
				UpperCamelCase__   : List[str]					  = None


UpperCamelCase__   : Dict					  = logging.get_logger(__name__)

UpperCamelCase__   : str					  = {"""vocab_file""": """spiece.model""", """tokenizer_file""": """tokenizer.json"""}

UpperCamelCase__   : Dict					  = {
    """vocab_file""": {
        """t5-small""": """https://huggingface.co/t5-small/resolve/main/spiece.model""",
        """t5-base""": """https://huggingface.co/t5-base/resolve/main/spiece.model""",
        """t5-large""": """https://huggingface.co/t5-large/resolve/main/spiece.model""",
        """t5-3b""": """https://huggingface.co/t5-3b/resolve/main/spiece.model""",
        """t5-11b""": """https://huggingface.co/t5-11b/resolve/main/spiece.model""",
    },
    """tokenizer_file""": {
        """t5-small""": """https://huggingface.co/t5-small/resolve/main/tokenizer.json""",
        """t5-base""": """https://huggingface.co/t5-base/resolve/main/tokenizer.json""",
        """t5-large""": """https://huggingface.co/t5-large/resolve/main/tokenizer.json""",
        """t5-3b""": """https://huggingface.co/t5-3b/resolve/main/tokenizer.json""",
        """t5-11b""": """https://huggingface.co/t5-11b/resolve/main/tokenizer.json""",
    },
}


# TODO(PVP) - this should be removed in Transformers v5
UpperCamelCase__   : Tuple					  = {
    """t5-small""": 5_12,
    """t5-base""": 5_12,
    """t5-large""": 5_12,
    """t5-3b""": 5_12,
    """t5-11b""": 5_12,
}







class   _UpperCamelCase  (       A_  ):







					'''simple docstring'''

					lowerCamelCase     :     List[str]			    =       VOCAB_FILES_NAMES
					lowerCamelCase     :     Any			    =       PRETRAINED_VOCAB_FILES_MAP
					lowerCamelCase     :     int			    =       PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
					lowerCamelCase     :     str			    =       ['input_ids', 'attention_mask']
					lowerCamelCase     :     List[str]			    =       TaTokenizer

					lowerCamelCase     :     List[int]			    =       []





					def __init__(						self    :  List[str] ,					__lowercase    :  Optional[Any]=None ,					__lowercase    :  Tuple=None ,					__lowercase    :  int="</s>" ,					__lowercase    :  Any="<unk>" ,					__lowercase    :  Union[str, Any]="<pad>" ,					__lowercase    :  Optional[Any]=1_00 ,					__lowercase    :  Union[str, Any]=None ,					**__lowercase    :  Union[str, Any] ,					):






						'''simple docstring'''







						if extra_ids > 0 and additional_special_tokens is None:
							UpperCAmelCase_								=     [F"""<extra_id_{i}>""" for i in range(__lowercase		)]
						elif extra_ids > 0 and additional_special_tokens is not None:
							# Check that we have the right number of extra special tokens
							UpperCAmelCase_								=     len(set(filter(lambda __lowercase		: bool("""extra_id_""" in str(__lowercase		)		) ,					__lowercase		)		)		)
							if extra_tokens != extra_ids:
								raise ValueError(
								    F"""Both extra_ids ({extra_ids}) and additional_special_tokens ({additional_special_tokens}) are"""
								    """ provided to T5Tokenizer. In this case the additional_special_tokens must include the extra_ids"""
								    """ tokens"""		)

						super().__init__(
						    __lowercase ,					tokenizer_file=__lowercase ,					eos_token=__lowercase ,					unk_token=__lowercase ,					pad_token=__lowercase ,					extra_ids=__lowercase ,					additional_special_tokens=__lowercase ,					**__lowercase ,					)

						UpperCAmelCase_								=     vocab_file
						UpperCAmelCase_								=     False if not self.vocab_file else True
						UpperCAmelCase_								=     extra_ids





					@staticmethod
					def        SCREAMING_SNAKE_CASE							(						__lowercase    :  int ,					__lowercase    :  Tuple ,					__lowercase    :  Any		):






						'''simple docstring'''







						if pretrained_model_name_or_path in TaTokenizerFast.max_model_input_sizes:
							UpperCAmelCase_								=     TaTokenizerFast.max_model_input_sizes[pretrained_model_name_or_path]
							if init_max_model_length is not None and init_max_model_length != max_model_length:
								return init_max_model_length
							elif init_max_model_length is None:
								warnings.warn(
								    """This tokenizer was incorrectly instantiated with a model max length of"""
								    F""" {deprecated_max_model_length} which will be corrected in Transformers v5.\nFor now, this"""
								    """ behavior is kept to avoid breaking backwards compatibility when padding/encoding with"""
								    """ `truncation is True`.\n- Be aware that you SHOULD NOT rely on"""
								    F""" {pretrained_model_name_or_path} automatically truncating your input to"""
								    F""" {deprecated_max_model_length} when padding/encoding.\n- If you want to encode/pad to sequences"""
								    F""" longer than {deprecated_max_model_length} you can either instantiate this tokenizer with"""
								    """ `model_max_length` or pass `max_length` when encoding/padding.\n- To avoid this warning, please"""
								    """ instantiate this tokenizer with `model_max_length` set to your preferred value.""" ,					__lowercase ,					)

						return max_model_length





					def        SCREAMING_SNAKE_CASE							(						self    :  Optional[Any] ,					__lowercase    :  str ,					__lowercase    :  Optional[str] = None		):






						'''simple docstring'''







						if not self.can_save_slow_tokenizer:
							raise ValueError(
							    """Your fast tokenizer does not have the necessary information to save the vocabulary for a slow """
							    """tokenizer."""		)

						if not os.path.isdir(__lowercase		):
							logger.error(F"""Vocabulary path ({save_directory}) should be a directory"""		)
							return
						UpperCAmelCase_								=     os.path.join(
						    __lowercase ,					(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]		)

						if os.path.abspath(self.vocab_file		) != os.path.abspath(__lowercase		):
							copyfile(self.vocab_file ,					__lowercase		)
							logger.info(F"""Copy vocab file to {out_vocab_file}"""		)

						return (out_vocab_file,)





					def        SCREAMING_SNAKE_CASE							(						self    :  Union[str, Any] ,					__lowercase    :  List[int] ,					__lowercase    :  Optional[List[int]] = None		):






						'''simple docstring'''







						UpperCAmelCase_								=     token_ids_a + [self.eos_token_id]
						if token_ids_a is None:
							return self.prefix_tokens + token_ids_a
						else:
							UpperCAmelCase_								=     token_ids_a + [self.eos_token_id]
							return self.prefix_tokens + token_ids_a + token_ids_a





					def        SCREAMING_SNAKE_CASE							(						self    :  List[str] ,					__lowercase    :  List[int] ,					__lowercase    :  Optional[List[int]] = None		):






						'''simple docstring'''







						UpperCAmelCase_								=     [self.eos_token_id]

						if token_ids_a is None:
							return len(token_ids_a + eos		) * [0]
						return len(token_ids_a + eos + token_ids_a + eos		) * [0]





					def        SCREAMING_SNAKE_CASE							(						self    :  Union[str, Any]		):






						'''simple docstring'''







						return list(
						    set(filter(lambda __lowercase		: bool(re.search(R"""<extra_id_\d+>""" ,					__lowercase		)		) is not None ,					self.additional_special_tokens		)		)		)





					def        SCREAMING_SNAKE_CASE							(						self    :  Optional[int]		):






						'''simple docstring'''







						return [self.convert_tokens_to_ids(__lowercase		) for token in self.get_sentinel_tokens()]









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

import numpy as np
import PIL
from PIL import Image

from ...utils import (
    BaseOutput,
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_k_diffusion_available,
    is_k_diffusion_version,
    is_onnx_available,
    is_torch_available,
    is_transformers_available,
    is_transformers_version,
)







@dataclass
class   _UpperCamelCase  (       A_  ):







					'''simple docstring'''

					lowerCamelCase     :     Union[List[PIL.Image.Image], np.ndarray]
					lowerCamelCase     :     Optional[List[bool]]


try:
				if not (is_transformers_available() and is_torch_available()):
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
				from .pipeline_cycle_diffusion import CycleDiffusionPipeline
				from .pipeline_stable_diffusion import StableDiffusionPipeline
				from .pipeline_stable_diffusion_attend_and_excite import StableDiffusionAttendAndExcitePipeline
				from .pipeline_stable_diffusion_imgaimg import StableDiffusionImgaImgPipeline
				from .pipeline_stable_diffusion_inpaint import StableDiffusionInpaintPipeline
				from .pipeline_stable_diffusion_inpaint_legacy import StableDiffusionInpaintPipelineLegacy
				from .pipeline_stable_diffusion_instruct_pixapix import StableDiffusionInstructPixaPixPipeline
				from .pipeline_stable_diffusion_latent_upscale import StableDiffusionLatentUpscalePipeline
				from .pipeline_stable_diffusion_ldmad import StableDiffusionLDMaDPipeline
				from .pipeline_stable_diffusion_model_editing import StableDiffusionModelEditingPipeline
				from .pipeline_stable_diffusion_panorama import StableDiffusionPanoramaPipeline
				from .pipeline_stable_diffusion_paradigms import StableDiffusionParadigmsPipeline
				from .pipeline_stable_diffusion_sag import StableDiffusionSAGPipeline
				from .pipeline_stable_diffusion_upscale import StableDiffusionUpscalePipeline
				from .pipeline_stable_unclip import StableUnCLIPPipeline
				from .pipeline_stable_unclip_imgaimg import StableUnCLIPImgaImgPipeline
				from .safety_checker import StableDiffusionSafetyChecker
				from .stable_unclip_image_normalizer import StableUnCLIPImageNormalizer

try:
				if not (is_transformers_available() and is_torch_available() and is_transformers_version(""">=""", """4.25.0""")):
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				from ...utils.dummy_torch_and_transformers_objects import StableDiffusionImageVariationPipeline
else:
				from .pipeline_stable_diffusion_image_variation import StableDiffusionImageVariationPipeline


try:
				if not (is_transformers_available() and is_torch_available() and is_transformers_version(""">=""", """4.26.0""")):
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				from ...utils.dummy_torch_and_transformers_objects import (
				    StableDiffusionDepthaImgPipeline,
				    StableDiffusionDiffEditPipeline,
				    StableDiffusionPixaPixZeroPipeline,
				)
else:
				from .pipeline_stable_diffusion_depthaimg import StableDiffusionDepthaImgPipeline
				from .pipeline_stable_diffusion_diffedit import StableDiffusionDiffEditPipeline
				from .pipeline_stable_diffusion_pixapix_zero import StableDiffusionPixaPixZeroPipeline


try:
				if not (
				    is_torch_available()
				    and is_transformers_available()
				    and is_k_diffusion_available()
				    and is_k_diffusion_version(""">=""", """0.0.12""")
				):
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				from ...utils.dummy_torch_and_transformers_and_k_diffusion_objects import *  # noqa F403
else:
				from .pipeline_stable_diffusion_k_diffusion import StableDiffusionKDiffusionPipeline

try:
				if not (is_transformers_available() and is_onnx_available()):
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				from ...utils.dummy_onnx_objects import *  # noqa F403
else:
				from .pipeline_onnx_stable_diffusion import OnnxStableDiffusionPipeline, StableDiffusionOnnxPipeline
				from .pipeline_onnx_stable_diffusion_imgaimg import OnnxStableDiffusionImgaImgPipeline
				from .pipeline_onnx_stable_diffusion_inpaint import OnnxStableDiffusionInpaintPipeline
				from .pipeline_onnx_stable_diffusion_inpaint_legacy import OnnxStableDiffusionInpaintPipelineLegacy
				from .pipeline_onnx_stable_diffusion_upscale import OnnxStableDiffusionUpscalePipeline

if is_transformers_available() and is_flax_available():
				import flax







				@flax.struct.dataclass
				class   _UpperCamelCase  (       A_  ):







									'''simple docstring'''

									lowerCamelCase     :     np.ndarray
									lowerCamelCase     :     List[bool]


				from ...schedulers.scheduling_pndm_flax import PNDMSchedulerState
				from .pipeline_flax_stable_diffusion import FlaxStableDiffusionPipeline
				from .pipeline_flax_stable_diffusion_imgaimg import FlaxStableDiffusionImgaImgPipeline
				from .pipeline_flax_stable_diffusion_inpaint import FlaxStableDiffusionInpaintPipeline
				from .safety_checker_flax import FlaxStableDiffusionSafetyChecker


