



'''simple docstring'''
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 _A     (			__SCREAMING_SNAKE_CASE			):
		_SCREAMING_SNAKE_CASE    :			Union[List[PIL.Image.Image], np.ndarray]
		_SCREAMING_SNAKE_CASE    :			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 _A     (			__SCREAMING_SNAKE_CASE			):
							_SCREAMING_SNAKE_CASE    :			np.ndarray
							_SCREAMING_SNAKE_CASE    :			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







"""simple docstring"""





import time
from contextlib import contextmanager
from pathlib import Path

import pytest
import requests
from huggingface_hub.hf_api import HfApi, HfFolder


_a       =							'__DUMMY_TRANSFORMERS_USER__'
_a       =							'Dummy User'
_a       =							'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'

_a       =							'https://hub-ci.huggingface.co'
_a       =							CI_HUB_ENDPOINT + '/datasets/{repo_id}/resolve/{revision}/{path}'
_a       =							CI_HUB_ENDPOINT + '/{repo_id}/resolve/{revision}/{filename}'
_a       =							Path('~/.huggingface/hub_ci_token').expanduser()




@pytest.fixture
def   _A  (  UpperCamelCase_     :       List[Any])	->						Tuple:
   '''simple docstring'''


   monkeypatch.setattr(
       "huggingface_hub.file_download.HUGGINGFACE_CO_URL_TEMPLATE",			UpperCamelCase_)




@pytest.fixture
def   _A  (  UpperCamelCase_     :       int)	->						List[Any]:
   '''simple docstring'''


   monkeypatch.setattr("datasets.config.HF_ENDPOINT",			UpperCamelCase_)
   monkeypatch.setattr("datasets.config.HUB_DATASETS_URL",			UpperCamelCase_)




@pytest.fixture
def   _A  (  UpperCamelCase_     :       str)	->						Dict:
   '''simple docstring'''


   monkeypatch.setattr("huggingface_hub.hf_api.HfFolder.path_token",			UpperCamelCase_)




@pytest.fixture
def   _A  (  UpperCamelCase_     :       Optional[Any],			UpperCamelCase_     :       List[Any])	->						List[str]:
   '''simple docstring'''


   HfFolder.save_token(UpperCamelCase_)
   yield
   HfFolder.delete_token()




@pytest.fixture(scope="session")
def   _A  (  )	->						List[Any]:
   '''simple docstring'''


   return HfApi(endpoint=UpperCamelCase_)




@pytest.fixture(scope="session")
def   _A  (  UpperCamelCase_     :       HfApi)	->						List[Any]:
   '''simple docstring'''


   __lowercase								=						HfFolder.get_token()
   HfFolder.save_token(UpperCamelCase_)
   yield CI_HUB_USER_TOKEN
   if previous_token is not None:
      HfFolder.save_token(UpperCamelCase_)




@pytest.fixture
def   _A  (  UpperCamelCase_     :       Dict)	->						int:
   '''simple docstring'''


   def _cleanup_repo(UpperCamelCase_     :       Optional[int]):
      hf_api.delete_repo(UpperCamelCase_,			token=UpperCamelCase_,			repo_type="dataset")

   return _cleanup_repo




@pytest.fixture
def   _A  (  UpperCamelCase_     :       str)	->						Any:
   '''simple docstring'''


   @contextmanager
   def _temporary_repo(UpperCamelCase_     :       Any):
      try:
         yield repo_id
      finally:
         cleanup_repo(UpperCamelCase_)

   return _temporary_repo




@pytest.fixture(scope="session")
def   _A  (  UpperCamelCase_     :       HfApi,			UpperCamelCase_     :       str,			UpperCamelCase_     :       Optional[int])	->						List[Any]:
   '''simple docstring'''


   __lowercase								=						F"""repo_txt_data-{int(time.time() * 10E3)}"""
   __lowercase								=						F"""{CI_HUB_USER}/{repo_name}"""
   hf_api.create_repo(UpperCamelCase_,			token=UpperCamelCase_,			repo_type="dataset",			private=UpperCamelCase_)
   hf_api.upload_file(
       token=UpperCamelCase_,			path_or_fileobj=str(UpperCamelCase_),			path_in_repo="data/text_data.txt",			repo_id=UpperCamelCase_,			repo_type="dataset",			)
   yield repo_id
   try:
      hf_api.delete_repo(UpperCamelCase_,			token=UpperCamelCase_,			repo_type="dataset")
   except (requests.exceptions.HTTPError, ValueError):  # catch http error and token invalid error
      pass




@pytest.fixture()
def   _A  (  UpperCamelCase_     :       Tuple,			UpperCamelCase_     :       Any,			UpperCamelCase_     :       Dict)	->						Optional[int]:
   '''simple docstring'''


   return hf_private_dataset_repo_txt_data_




@pytest.fixture(scope="session")
def   _A  (  UpperCamelCase_     :       HfApi,			UpperCamelCase_     :       int,			UpperCamelCase_     :       Optional[int])	->						int:
   '''simple docstring'''


   __lowercase								=						F"""repo_zipped_txt_data-{int(time.time() * 10E3)}"""
   __lowercase								=						F"""{CI_HUB_USER}/{repo_name}"""
   hf_api.create_repo(UpperCamelCase_,			token=UpperCamelCase_,			repo_type="dataset",			private=UpperCamelCase_)
   hf_api.upload_file(
       token=UpperCamelCase_,			path_or_fileobj=str(UpperCamelCase_),			path_in_repo="data.zip",			repo_id=UpperCamelCase_,			repo_type="dataset",			)
   yield repo_id
   try:
      hf_api.delete_repo(UpperCamelCase_,			token=UpperCamelCase_,			repo_type="dataset")
   except (requests.exceptions.HTTPError, ValueError):  # catch http error and token invalid error
      pass




@pytest.fixture()
def   _A  (  UpperCamelCase_     :       List[str],			UpperCamelCase_     :       Dict,			UpperCamelCase_     :       Any)	->						int:
   '''simple docstring'''


   return hf_private_dataset_repo_zipped_txt_data_




@pytest.fixture(scope="session")
def   _A  (  UpperCamelCase_     :       HfApi,			UpperCamelCase_     :       List[str],			UpperCamelCase_     :       List[str])	->						List[Any]:
   '''simple docstring'''


   __lowercase								=						F"""repo_zipped_img_data-{int(time.time() * 10E3)}"""
   __lowercase								=						F"""{CI_HUB_USER}/{repo_name}"""
   hf_api.create_repo(UpperCamelCase_,			token=UpperCamelCase_,			repo_type="dataset",			private=UpperCamelCase_)
   hf_api.upload_file(
       token=UpperCamelCase_,			path_or_fileobj=str(UpperCamelCase_),			path_in_repo="data.zip",			repo_id=UpperCamelCase_,			repo_type="dataset",			)
   yield repo_id
   try:
      hf_api.delete_repo(UpperCamelCase_,			token=UpperCamelCase_,			repo_type="dataset")
   except (requests.exceptions.HTTPError, ValueError):  # catch http error and token invalid error
      pass




@pytest.fixture()
def   _A  (  UpperCamelCase_     :       Union[str, Any],			UpperCamelCase_     :       List[str],			UpperCamelCase_     :       List[str])	->						str:
   '''simple docstring'''


   return hf_private_dataset_repo_zipped_img_data_




