





import os
import unicodedata
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


_A					:				Tuple				=			logging.get_logger(__name__)
_A					:				Optional[int]				=			{"""vocab_file""": """spiece.model"""}

_A					:				List[Any]				=			{
    """vocab_file""": {
        """albert-base-v1""": """https://huggingface.co/albert-base-v1/resolve/main/spiece.model""",
        """albert-large-v1""": """https://huggingface.co/albert-large-v1/resolve/main/spiece.model""",
        """albert-xlarge-v1""": """https://huggingface.co/albert-xlarge-v1/resolve/main/spiece.model""",
        """albert-xxlarge-v1""": """https://huggingface.co/albert-xxlarge-v1/resolve/main/spiece.model""",
        """albert-base-v2""": """https://huggingface.co/albert-base-v2/resolve/main/spiece.model""",
        """albert-large-v2""": """https://huggingface.co/albert-large-v2/resolve/main/spiece.model""",
        """albert-xlarge-v2""": """https://huggingface.co/albert-xlarge-v2/resolve/main/spiece.model""",
        """albert-xxlarge-v2""": """https://huggingface.co/albert-xxlarge-v2/resolve/main/spiece.model""",
    }
}

_A					:				Tuple				=			{
    """albert-base-v1""": 5_12,
    """albert-large-v1""": 5_12,
    """albert-xlarge-v1""": 5_12,
    """albert-xxlarge-v1""": 5_12,
    """albert-base-v2""": 5_12,
    """albert-large-v2""": 5_12,
    """albert-xlarge-v2""": 5_12,
    """albert-xxlarge-v2""": 5_12,
}

_A					:				Optional[Any]				=			"""▁"""



class 					__snake_case	(  __SCREAMING_SNAKE_CASE    ):


    '''simple docstring'''







    lowerCamelCase__    :		Dict				=	VOCAB_FILES_NAMES
    lowerCamelCase__    :		Optional[Any]				=	PRETRAINED_VOCAB_FILES_MAP
    lowerCamelCase__    :		List[Any]				=	PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES



    def __init__(       self   ,				A_   ,				A_=True   ,				A_=True   ,				A_=False   ,				A_="[CLS]"   ,				A_="[SEP]"   ,				A_="<unk>"   ,				A_="[SEP]"   ,				A_="<pad>"   ,				A_="[CLS]"   ,				A_="[MASK]"   ,				A_ = None   ,				**A_   ,				):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			(
            AddedToken(A_   ,				lstrip=A_   ,				rstrip=A_   ,				normalized=A_     )
            if isinstance(A_   ,				A_     )
            else mask_token
        )

        SCREAMING_SNAKE_CASE__											=			{} if sp_model_kwargs is None else sp_model_kwargs

        super().__init__(
            do_lower_case=A_   ,				remove_space=A_   ,				keep_accents=A_   ,				bos_token=A_   ,				eos_token=A_   ,				unk_token=A_   ,				sep_token=A_   ,				pad_token=A_   ,				cls_token=A_   ,				mask_token=A_   ,				sp_model_kwargs=self.sp_model_kwargs   ,				**A_   ,				)

        SCREAMING_SNAKE_CASE__											=			do_lower_case
        SCREAMING_SNAKE_CASE__											=			remove_space
        SCREAMING_SNAKE_CASE__											=			keep_accents
        SCREAMING_SNAKE_CASE__											=			vocab_file

        SCREAMING_SNAKE_CASE__											=			spm.SentencePieceProcessor(**self.sp_model_kwargs     )
        self.sp_model.Load(A_     )



    @property
    def  lowercase_					(       self     ):





        '''simple docstring'''

        return len(self.sp_model     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			{self.convert_ids_to_tokens(A_     ): i for i in range(self.vocab_size     )}
        vocab.update(self.added_tokens_encoder     )
        return vocab



    def __getstate__(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.__dict__.copy()
        SCREAMING_SNAKE_CASE__											=			None
        return state



    def __setstate__(       self   ,				A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			d

        # for backward compatibility
        if not hasattr(self   ,				'''sp_model_kwargs'''     ):
            SCREAMING_SNAKE_CASE__											=			{}

        SCREAMING_SNAKE_CASE__											=			spm.SentencePieceProcessor(**self.sp_model_kwargs     )
        self.sp_model.Load(self.vocab_file     )



    def  lowercase_					(       self   ,				A_     ):





        '''simple docstring'''

        if self.remove_space:
            SCREAMING_SNAKE_CASE__											=			''' '''.join(inputs.strip().split()     )
        else:
            SCREAMING_SNAKE_CASE__											=			inputs
        SCREAMING_SNAKE_CASE__											=			outputs.replace('''``'''   ,				'''"'''     ).replace('''\'\''''   ,				'''"'''     )

        if not self.keep_accents:
            SCREAMING_SNAKE_CASE__											=			unicodedata.normalize('''NFKD'''   ,				A_     )
            SCREAMING_SNAKE_CASE__											=			''''''.join([c for c in outputs if not unicodedata.combining(A_     )]     )
        if self.do_lower_case:
            SCREAMING_SNAKE_CASE__											=			outputs.lower()

        return outputs



    def  lowercase_					(       self   ,				A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.preprocess_text(A_     )
        SCREAMING_SNAKE_CASE__											=			self.sp_model.encode(A_   ,				out_type=A_     )
        SCREAMING_SNAKE_CASE__											=			[]
        for piece in pieces:
            if len(A_     ) > 1 and piece[-1] == str(''','''     ) and piece[-2].isdigit():
                SCREAMING_SNAKE_CASE__											=			self.sp_model.EncodeAsPieces(piece[:-1].replace(A_   ,				''''''     )     )
                if piece[0] != SPIECE_UNDERLINE and cur_pieces[0][0] == SPIECE_UNDERLINE:
                    if len(cur_pieces[0]     ) == 1:
                        SCREAMING_SNAKE_CASE__											=			cur_pieces[1:]
                    else:
                        SCREAMING_SNAKE_CASE__											=			cur_pieces[0][1:]
                cur_pieces.append(piece[-1]     )
                new_pieces.extend(A_     )
            else:
                new_pieces.append(A_     )

        return new_pieces



    def  lowercase_					(       self   ,				A_     ):





        '''simple docstring'''

        return self.sp_model.PieceToId(A_     )



    def  lowercase_					(       self   ,				A_     ):





        '''simple docstring'''

        return self.sp_model.IdToPiece(A_     )



    def  lowercase_					(       self   ,				A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			[]
        SCREAMING_SNAKE_CASE__											=			''''''
        SCREAMING_SNAKE_CASE__											=			False
        for token in tokens:
            # make sure that special tokens are not decoded using sentencepiece model
            if token in self.all_special_tokens:
                if not prev_is_special:
                    out_string += " "
                out_string += self.sp_model.decode(A_     ) + token
                SCREAMING_SNAKE_CASE__											=			True
                SCREAMING_SNAKE_CASE__											=			[]
            else:
                current_sub_tokens.append(A_     )
                SCREAMING_SNAKE_CASE__											=			False
        out_string += self.sp_model.decode(A_     )
        return out_string.strip()



    def  lowercase_					(       self   ,				A_   ,				A_ = None     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			[self.sep_token_id]
        SCREAMING_SNAKE_CASE__											=			[self.cls_token_id]
        if token_ids_a is None:
            return cls + token_ids_a + sep
        return cls + token_ids_a + sep + token_ids_a + sep



    def  lowercase_					(       self   ,				A_   ,				A_ = None   ,				A_ = False     ):





        '''simple docstring'''

        if already_has_special_tokens:
            return super().get_special_tokens_mask(
                token_ids_a=A_   ,				token_ids_a=A_   ,				already_has_special_tokens=A_     )

        if token_ids_a is not None:
            return [1] + ([0] * len(A_     )) + [1] + ([0] * len(A_     )) + [1]
        return [1] + ([0] * len(A_     )) + [1]



    def  lowercase_					(       self   ,				A_   ,				A_ = None     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			[self.sep_token_id]
        SCREAMING_SNAKE_CASE__											=			[self.cls_token_id]

        if token_ids_a is None:
            return len(cls + token_ids_a + sep     ) * [0]
        return len(cls + token_ids_a + sep     ) * [0] + len(token_ids_a + sep     ) * [1]




    def  lowercase_					(       self   ,				A_   ,				A_ = None     ):





        '''simple docstring'''

        if not os.path.isdir(A_     ):
            logger.error(f'''Vocabulary path ({save_directory}) should be a directory'''     )
            return
        SCREAMING_SNAKE_CASE__											=			os.path.join(
            A_   ,				(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']     )

        if os.path.abspath(self.vocab_file     ) != os.path.abspath(A_     ) and os.path.isfile(self.vocab_file     ):
            copyfile(self.vocab_file   ,				A_     )
        elif not os.path.isfile(self.vocab_file     ):
            with open(A_   ,				'''wb'''     ) as fi:
                SCREAMING_SNAKE_CASE__											=			self.sp_model.serialized_model_proto()
                fi.write(A_     )

        return (out_vocab_file,)







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 	__lowerCAmelCase      (       _UpperCamelCase	):
   _UpperCamelCase			:    Union[List[PIL.Image.Image], np.ndarray]
   _UpperCamelCase			:    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 	__lowerCAmelCase      (       _UpperCamelCase	):
     _UpperCamelCase			:    np.ndarray
     _UpperCamelCase			:    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

