
'''simple docstring'''



import gc
import random
import tempfile
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.stable_diffusion_safe import StableDiffusionPipelineSafe as StableDiffusionPipeline
from diffusers.utils import floats_tensor, nightly, torch_device
from diffusers.utils.testing_utils import require_torch_gpu




class   UpperCAmelCase_					(		unittest.TestCase			):






						'''simple docstring'''






						def  _lowercase     ( self				):

												"""simple docstring"""



												super().tearDown()
												gc.collect()
												torch.cuda.empty_cache()




						@property
						def  _lowercase     ( self				):

												"""simple docstring"""



												_lowerCAmelCase  						=			1
												_lowerCAmelCase  						=			3
												_lowerCAmelCase  						=			(32, 32)

												_lowerCAmelCase  						=			floats_tensor((batch_size, num_channels) + sizes   ,       rng=random.Random(0				)				).to(_a				)
												return image




						@property
						def  _lowercase     ( self				):

												"""simple docstring"""



												torch.manual_seed(0				)
												_lowerCAmelCase  						=			UNetaDConditionModel(
												    block_out_channels=(32, 64)   ,       layers_per_block=2   ,       sample_size=32   ,       in_channels=4   ,       out_channels=4   ,       down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")   ,       up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")   ,       cross_attention_dim=32   ,       )
												return model




						@property
						def  _lowercase     ( self				):

												"""simple docstring"""



												torch.manual_seed(0				)
												_lowerCAmelCase  						=			AutoencoderKL(
												    block_out_channels=[32, 64]   ,       in_channels=3   ,       out_channels=3   ,       down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]   ,       up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]   ,       latent_channels=4   ,       )
												return model




						@property
						def  _lowercase     ( self				):

												"""simple docstring"""



												torch.manual_seed(0				)
												_lowerCAmelCase  						=			CLIPTextConfig(
												    bos_token_id=0   ,       eos_token_id=2   ,       hidden_size=32   ,       intermediate_size=37   ,       layer_norm_eps=1e-05   ,       num_attention_heads=4   ,       num_hidden_layers=5   ,       pad_token_id=1   ,       vocab_size=1_000   ,       )
												return CLIPTextModel(_a				)




						@property
						def  _lowercase     ( self				):

												"""simple docstring"""



												def extract(*_lowercase   ,       **_lowercase				):




																		class   UpperCAmelCase_					:






																								'''simple docstring'''






																								def __init__( self				):

																														"""simple docstring"""



																														_lowerCAmelCase  						=			torch.ones([0]				)




																								def  _lowercase     ( self   ,       _lowercase				):

																														"""simple docstring"""



																														self.pixel_values.to(_a				)
																														return self






																		return Out()

												return extract




						def  _lowercase     ( self				):

												"""simple docstring"""



												_lowerCAmelCase  						=			'''cpu'''  # ensure determinism for the device-dependent torch.Generator
												_lowerCAmelCase  						=			self.dummy_cond_unet
												_lowerCAmelCase  						=			DDIMScheduler(
												    beta_start=0.0_0085   ,       beta_end=0.012   ,       beta_schedule="""scaled_linear"""   ,       clip_sample=_a   ,       set_alpha_to_one=_a   ,       )

												_lowerCAmelCase  						=			self.dummy_vae
												_lowerCAmelCase  						=			self.dummy_text_encoder
												_lowerCAmelCase  						=			CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""				)

												# make sure here that pndm scheduler skips prk
												_lowerCAmelCase  						=			StableDiffusionPipeline(
												    unet=_a   ,       scheduler=_a   ,       vae=_a   ,       text_encoder=_a   ,       tokenizer=_a   ,       safety_checker=_a   ,       feature_extractor=self.dummy_extractor   ,       )
												_lowerCAmelCase  						=			sd_pipe.to(_a				)
												sd_pipe.set_progress_bar_config(disable=_a				)

												_lowerCAmelCase  						=			'''A painting of a squirrel eating a burger'''

												_lowerCAmelCase  						=			torch.Generator(device=_a				).manual_seed(0				)
												_lowerCAmelCase  						=			sd_pipe([prompt]   ,       generator=_a   ,       guidance_scale=6.0   ,       num_inference_steps=2   ,       output_type="""np"""				)
												_lowerCAmelCase  						=			output.images

												_lowerCAmelCase  						=			torch.Generator(device=_a				).manual_seed(0				)
												_lowerCAmelCase  						=			sd_pipe(
												    [prompt]   ,       generator=_a   ,       guidance_scale=6.0   ,       num_inference_steps=2   ,       output_type="""np"""   ,       return_dict=_a   ,       )[0]

												_lowerCAmelCase  						=			image[0, -3:, -3:, -1]
												_lowerCAmelCase  						=			image_from_tuple[0, -3:, -3:, -1]

												assert image.shape == (1, 64, 64, 3)
												_lowerCAmelCase  						=			np.array([0.5756, 0.6118, 0.5005, 0.5041, 0.5471, 0.4726, 0.4976, 0.4865, 0.4864]				)

												assert np.abs(image_slice.flatten() - expected_slice				).max() < 1e-2
												assert np.abs(image_from_tuple_slice.flatten() - expected_slice				).max() < 1e-2




						def  _lowercase     ( self				):

												"""simple docstring"""



												_lowerCAmelCase  						=			'''cpu'''  # ensure determinism for the device-dependent torch.Generator
												_lowerCAmelCase  						=			self.dummy_cond_unet
												_lowerCAmelCase  						=			PNDMScheduler(skip_prk_steps=_a				)
												_lowerCAmelCase  						=			self.dummy_vae
												_lowerCAmelCase  						=			self.dummy_text_encoder
												_lowerCAmelCase  						=			CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""				)

												# make sure here that pndm scheduler skips prk
												_lowerCAmelCase  						=			StableDiffusionPipeline(
												    unet=_a   ,       scheduler=_a   ,       vae=_a   ,       text_encoder=_a   ,       tokenizer=_a   ,       safety_checker=_a   ,       feature_extractor=self.dummy_extractor   ,       )
												_lowerCAmelCase  						=			sd_pipe.to(_a				)
												sd_pipe.set_progress_bar_config(disable=_a				)

												_lowerCAmelCase  						=			'''A painting of a squirrel eating a burger'''
												_lowerCAmelCase  						=			torch.Generator(device=_a				).manual_seed(0				)
												_lowerCAmelCase  						=			sd_pipe([prompt]   ,       generator=_a   ,       guidance_scale=6.0   ,       num_inference_steps=2   ,       output_type="""np"""				)

												_lowerCAmelCase  						=			output.images

												_lowerCAmelCase  						=			torch.Generator(device=_a				).manual_seed(0				)
												_lowerCAmelCase  						=			sd_pipe(
												    [prompt]   ,       generator=_a   ,       guidance_scale=6.0   ,       num_inference_steps=2   ,       output_type="""np"""   ,       return_dict=_a   ,       )[0]

												_lowerCAmelCase  						=			image[0, -3:, -3:, -1]
												_lowerCAmelCase  						=			image_from_tuple[0, -3:, -3:, -1]

												assert image.shape == (1, 64, 64, 3)
												_lowerCAmelCase  						=			np.array([0.5125, 0.5716, 0.4828, 0.5060, 0.5650, 0.4768, 0.5185, 0.4895, 0.4993]				)

												assert np.abs(image_slice.flatten() - expected_slice				).max() < 1e-2
												assert np.abs(image_from_tuple_slice.flatten() - expected_slice				).max() < 1e-2




						def  _lowercase     ( self				):

												"""simple docstring"""



												_lowerCAmelCase  						=			StableDiffusionPipeline.from_pretrained(
												    """hf-internal-testing/tiny-stable-diffusion-lms-pipe"""   ,       safety_checker=_a				)
												assert isinstance(_a   ,       _a				)
												assert isinstance(pipe.scheduler   ,       _a				)
												assert pipe.safety_checker is None

												_lowerCAmelCase  						=			pipe("""example prompt"""   ,       num_inference_steps=2				).images[0]
												assert image is not None

												# check that there's no error when saving a pipeline with one of the models being None
												with tempfile.TemporaryDirectory() as tmpdirname:
																		pipe.save_pretrained(_a				)
																		_lowerCAmelCase  						=			StableDiffusionPipeline.from_pretrained(_a				)

												# sanity check that the pipeline still works
												assert pipe.safety_checker is None
												_lowerCAmelCase  						=			pipe("""example prompt"""   ,       num_inference_steps=2				).images[0]
												assert image is not None




						@unittest.skipIf(torch_device != """cuda"""   ,       """This test requires a GPU"""				)
						def  _lowercase     ( self				):

												"""simple docstring"""



												_lowerCAmelCase  						=			self.dummy_cond_unet
												_lowerCAmelCase  						=			PNDMScheduler(skip_prk_steps=_a				)
												_lowerCAmelCase  						=			self.dummy_vae
												_lowerCAmelCase  						=			self.dummy_text_encoder
												_lowerCAmelCase  						=			CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""				)

												# put models in fp16
												_lowerCAmelCase  						=			unet.half()
												_lowerCAmelCase  						=			vae.half()
												_lowerCAmelCase  						=			bert.half()

												# make sure here that pndm scheduler skips prk
												_lowerCAmelCase  						=			StableDiffusionPipeline(
												    unet=_a   ,       scheduler=_a   ,       vae=_a   ,       text_encoder=_a   ,       tokenizer=_a   ,       safety_checker=_a   ,       feature_extractor=self.dummy_extractor   ,       )
												_lowerCAmelCase  						=			sd_pipe.to(_a				)
												sd_pipe.set_progress_bar_config(disable=_a				)

												_lowerCAmelCase  						=			'''A painting of a squirrel eating a burger'''
												_lowerCAmelCase  						=			sd_pipe([prompt]   ,       num_inference_steps=2   ,       output_type="""np"""				).images

												assert image.shape == (1, 64, 64, 3)






@nightly
@require_torch_gpu
class   UpperCAmelCase_					(		unittest.TestCase			):






						'''simple docstring'''






						def  _lowercase     ( self				):

												"""simple docstring"""



												super().tearDown()
												gc.collect()
												torch.cuda.empty_cache()




						def  _lowercase     ( self				):

												"""simple docstring"""



												_lowerCAmelCase  						=			StableDiffusionPipeline.from_pretrained("""runwayml/stable-diffusion-v1-5"""   ,       safety_checker=_a				)
												_lowerCAmelCase  						=			LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config				)
												_lowerCAmelCase  						=			sd_pipe.to(_a				)
												sd_pipe.set_progress_bar_config(disable=_a				)

												_lowerCAmelCase  						=			(
												    '''portrait of girl with smokey eyes makeup in abandoned hotel, grange clothes, redshift, wide high angle'''
												    ''' coloured polaroid photograph with flash, kodak film, hyper real, stunning moody cinematography, with'''
												    ''' anamorphic lenses, by maripol, fallen angels by wong kar - wai, style of suspiria and neon demon and'''
												    ''' children from bahnhof zoo, detailed '''
												)
												_lowerCAmelCase  						=			4_003_660_346
												_lowerCAmelCase  						=			7

												# without safety guidance (sld_guidance_scale = 0)
												_lowerCAmelCase  						=			torch.manual_seed(_a				)
												_lowerCAmelCase  						=			sd_pipe(
												    [prompt]   ,       generator=_a   ,       guidance_scale=_a   ,       num_inference_steps=50   ,       output_type="""np"""   ,       width=512   ,       height=512   ,       sld_guidance_scale=0   ,       )

												_lowerCAmelCase  						=			output.images
												_lowerCAmelCase  						=			image[0, -3:, -3:, -1]
												_lowerCAmelCase  						=			[0.2278, 0.2231, 0.2249, 0.2333, 0.2303, 0.1885, 0.2273, 0.2144, 0.2176]

												assert image.shape == (1, 512, 512, 3)

												assert np.abs(image_slice.flatten() - expected_slice				).max() < 1e-2

												# without safety guidance (strong configuration)
												_lowerCAmelCase  						=			torch.manual_seed(_a				)
												_lowerCAmelCase  						=			sd_pipe(
												    [prompt]   ,       generator=_a   ,       guidance_scale=_a   ,       num_inference_steps=50   ,       output_type="""np"""   ,       width=512   ,       height=512   ,       sld_guidance_scale=2_000   ,       sld_warmup_steps=7   ,       sld_threshold=0.025   ,       sld_momentum_scale=0.5   ,       sld_mom_beta=0.7   ,       )

												_lowerCAmelCase  						=			output.images
												_lowerCAmelCase  						=			image[0, -3:, -3:, -1]
												_lowerCAmelCase  						=			[0.2383, 0.2276, 0.236, 0.2192, 0.2186, 0.2053, 0.1971, 0.1901, 0.1719]

												assert image.shape == (1, 512, 512, 3)

												assert np.abs(image_slice.flatten() - expected_slice				).max() < 1e-2




						def  _lowercase     ( self				):

												"""simple docstring"""



												_lowerCAmelCase  						=			StableDiffusionPipeline.from_pretrained("""runwayml/stable-diffusion-v1-5"""   ,       safety_checker=_a				)
												_lowerCAmelCase  						=			LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config				)
												_lowerCAmelCase  						=			sd_pipe.to(_a				)
												sd_pipe.set_progress_bar_config(disable=_a				)

												_lowerCAmelCase  						=			'''padme amidala taking a bath artwork, safe for work, no nudity'''
												_lowerCAmelCase  						=			2_734_971_755
												_lowerCAmelCase  						=			7

												_lowerCAmelCase  						=			torch.manual_seed(_a				)
												_lowerCAmelCase  						=			sd_pipe(
												    [prompt]   ,       generator=_a   ,       guidance_scale=_a   ,       num_inference_steps=50   ,       output_type="""np"""   ,       width=512   ,       height=512   ,       sld_guidance_scale=0   ,       )

												_lowerCAmelCase  						=			output.images
												_lowerCAmelCase  						=			image[0, -3:, -3:, -1]
												_lowerCAmelCase  						=			[0.3502, 0.3622, 0.3396, 0.3642, 0.3478, 0.3318, 0.35, 0.3348, 0.3297]

												assert image.shape == (1, 512, 512, 3)

												assert np.abs(image_slice.flatten() - expected_slice				).max() < 1e-2

												_lowerCAmelCase  						=			torch.manual_seed(_a				)
												_lowerCAmelCase  						=			sd_pipe(
												    [prompt]   ,       generator=_a   ,       guidance_scale=_a   ,       num_inference_steps=50   ,       output_type="""np"""   ,       width=512   ,       height=512   ,       sld_guidance_scale=2_000   ,       sld_warmup_steps=7   ,       sld_threshold=0.025   ,       sld_momentum_scale=0.5   ,       sld_mom_beta=0.7   ,       )

												_lowerCAmelCase  						=			output.images
												_lowerCAmelCase  						=			image[0, -3:, -3:, -1]
												_lowerCAmelCase  						=			[0.5531, 0.5206, 0.4895, 0.5156, 0.5182, 0.4751, 0.4802, 0.4803, 0.4443]

												assert image.shape == (1, 512, 512, 3)

												assert np.abs(image_slice.flatten() - expected_slice				).max() < 1e-2




						def  _lowercase     ( self				):

												"""simple docstring"""



												_lowerCAmelCase  						=			StableDiffusionPipeline.from_pretrained("""runwayml/stable-diffusion-v1-5"""				)
												_lowerCAmelCase  						=			sd_pipe.to(_a				)
												sd_pipe.set_progress_bar_config(disable=_a				)

												_lowerCAmelCase  						=			(
												    '''the four horsewomen of the apocalypse, painting by tom of finland, gaston bussiere, craig mullins, j. c.'''
												    ''' leyendecker'''
												)
												_lowerCAmelCase  						=			1_044_355_234
												_lowerCAmelCase  						=			12

												_lowerCAmelCase  						=			torch.manual_seed(_a				)
												_lowerCAmelCase  						=			sd_pipe(
												    [prompt]   ,       generator=_a   ,       guidance_scale=_a   ,       num_inference_steps=50   ,       output_type="""np"""   ,       width=512   ,       height=512   ,       sld_guidance_scale=0   ,       )

												_lowerCAmelCase  						=			output.images
												_lowerCAmelCase  						=			image[0, -3:, -3:, -1]
												_lowerCAmelCase  						=			np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]				)

												assert image.shape == (1, 512, 512, 3)

												assert np.abs(image_slice.flatten() - expected_slice				).max() < 1e-7

												_lowerCAmelCase  						=			torch.manual_seed(_a				)
												_lowerCAmelCase  						=			sd_pipe(
												    [prompt]   ,       generator=_a   ,       guidance_scale=_a   ,       num_inference_steps=50   ,       output_type="""np"""   ,       width=512   ,       height=512   ,       sld_guidance_scale=2_000   ,       sld_warmup_steps=7   ,       sld_threshold=0.025   ,       sld_momentum_scale=0.5   ,       sld_mom_beta=0.7   ,       )

												_lowerCAmelCase  						=			output.images
												_lowerCAmelCase  						=			image[0, -3:, -3:, -1]
												_lowerCAmelCase  						=			np.array([0.5818, 0.6285, 0.6835, 0.6019, 0.625, 0.6754, 0.6096, 0.6334, 0.6561]				)
												assert image.shape == (1, 512, 512, 3)

												assert np.abs(image_slice.flatten() - expected_slice				).max() < 1e-2



'''simple docstring'''



# Lint as: python3
# pylint: enable=line-too-long
# pylint: disable=g-import-not-at-top,g-bad-import-order,wrong-import-position

_lowercase    =		"""2.13.1"""

import platform

import pyarrow
from packaging import version


if version.parse(platform.python_version()) < version.parse("""3.7"""):
						raise ImportWarning(
						    """To use `datasets`, Python>=3.7 is required, and the current version of Python doesn't match this condition."""
						)

if version.parse(pyarrow.__version__).major < 8:
						raise ImportWarning(
						    """To use `datasets`, the module `pyarrow>=8.0.0` is required, and the current version of `pyarrow` doesn't match this condition.\n"""
						    """If you are running this in a Google Colab, you should probably just restart the runtime to use the right version of `pyarrow`."""
						)

del platform
del pyarrow
del version

from .arrow_dataset import Dataset
from .arrow_reader import ReadInstruction
from .builder import ArrowBasedBuilder, BeamBasedBuilder, BuilderConfig, DatasetBuilder, GeneratorBasedBuilder
from .combine import concatenate_datasets, interleave_datasets
from .dataset_dict import DatasetDict, IterableDatasetDict
from .download import *
from .features import *
from .fingerprint import disable_caching, enable_caching, is_caching_enabled, set_caching_enabled
from .info import DatasetInfo, MetricInfo
from .inspect import (
    get_dataset_config_info,
    get_dataset_config_names,
    get_dataset_infos,
    get_dataset_split_names,
    inspect_dataset,
    inspect_metric,
    list_datasets,
    list_metrics,
)
from .iterable_dataset import IterableDataset
from .load import load_dataset, load_dataset_builder, load_from_disk, load_metric
from .metric import Metric
from .splits import (
    NamedSplit,
    NamedSplitAll,
    Split,
    SplitBase,
    SplitDict,
    SplitGenerator,
    SplitInfo,
    SubSplitInfo,
    percent,
)
from .tasks import *
from .utils import *
from .utils import logging


# deprecated modules
from datasets import arrow_dataset as _arrow_dataset  # isort:skip
from datasets import utils as _utils  # isort:skip
from datasets.utils import download_manager as _deprecated_download_manager  # isort:skip

_lowercase    =		concatenate_datasets
_lowercase    =		DownloadConfig
_lowercase    =		DownloadManager
_lowercase    =		DownloadMode
_lowercase    =		DownloadConfig
_lowercase    =		DownloadMode
_lowercase    =		DownloadManager

del _arrow_dataset, _utils, _deprecated_download_manager
