






import collections
import gzip
import os
import urllib

import numpy
from tensorflow.python.framework import dtypes, random_seed
from tensorflow.python.platform import gfile
from tensorflow.python.util.deprecation import deprecated

__magic_name__:					str							=     collections.namedtuple("_Datasets", ["train", "validation", "test"])

# CVDF mirror of http://yann.lecun.com/exdb/mnist/
__magic_name__:					Dict							=     "https://storage.googleapis.com/cvdf-datasets/mnist/"

def    UpperCamelCase						(	_A			):






						"""simple docstring"""







						__magic_name__      :       Optional[int]       						= numpy.dtype(numpy.uintaa			).newbyteorder(""">"""			)
						return numpy.frombuffer(bytestream.read(4			),   dtype=_A			)[0]

@deprecated(_A,   """Please use tf.data to implement this functionality."""			)
def    UpperCamelCase						(	_A			):






						"""simple docstring"""







						print("""Extracting""",   f.name			)
						with gzip.GzipFile(fileobj=_A			) as bytestream:
												__magic_name__      :       Optional[Any]       						= _readaa(_A			)
												if magic != 2051:
																		raise ValueError(
																		    """Invalid magic number %d in MNIST image file: %s""" % (magic, f.name)			)
												__magic_name__      :       int       						= _readaa(_A			)
												__magic_name__      :       Tuple       						= _readaa(_A			)
												__magic_name__      :       str       						= _readaa(_A			)
												__magic_name__      :       Any       						= bytestream.read(rows * cols * num_images			)
												__magic_name__      :       List[str]       						= numpy.frombuffer(_A,   dtype=numpy.uinta			)
												__magic_name__      :       List[str]       						= data.reshape(_A,   _A,   _A,   1			)
												return data

@deprecated(_A,   """Please use tf.one_hot on tensors."""			)
def    UpperCamelCase						(	_A,   _A			):






						"""simple docstring"""







						__magic_name__      :       Any       						= labels_dense.shape[0]
						__magic_name__      :       Union[str, Any]       						= numpy.arange(_A			) * num_classes
						__magic_name__      :       str       						= numpy.zeros((num_labels, num_classes)			)
						__magic_name__      :       Optional[Any]       						= 1
						return labels_one_hot

@deprecated(_A,   """Please use tf.data to implement this functionality."""			)
def    UpperCamelCase						(	_A,   _A=False,   _A=10			):






						"""simple docstring"""







						print("""Extracting""",   f.name			)
						with gzip.GzipFile(fileobj=_A			) as bytestream:
												__magic_name__      :       List[str]       						= _readaa(_A			)
												if magic != 2049:
																		raise ValueError(
																		    """Invalid magic number %d in MNIST label file: %s""" % (magic, f.name)			)
												__magic_name__      :       Tuple       						= _readaa(_A			)
												__magic_name__      :       Union[str, Any]       						= bytestream.read(_A			)
												__magic_name__      :       Dict       						= numpy.frombuffer(_A,   dtype=numpy.uinta			)
												if one_hot:
																		return _dense_to_one_hot(_A,   _A			)
												return labels





class 	snake_case__ :
	@deprecated(
	    lowerCAmelCase__      ,       """Please use alternatives such as official/mnist/_DataSet.py"""
	    """ from tensorflow/models."""      ,       )
	def __init__(    self      ,       lowerCAmelCase__      ,       lowerCAmelCase__      ,       lowerCAmelCase__=False      ,       lowerCAmelCase__=False      ,       lowerCAmelCase__=dtypes.floataa      ,       lowerCAmelCase__=True      ,       lowerCAmelCase__=None      ,       )							->				int:
							__magic_name__      :       Dict       						= random_seed.get_seed(lowerCAmelCase__			)
							# If op level seed is not set, use whatever graph level seed is returned
							numpy.random.seed(seeda if seed is None else seeda			)
							__magic_name__      :       int       						= dtypes.as_dtype(lowerCAmelCase__			).base_dtype
							if dtype not in (dtypes.uinta, dtypes.floataa):
													raise TypeError("""Invalid image dtype %r, expected uint8 or float32""" % dtype			)
							if fake_data:
													__magic_name__      :       Optional[Any]       						= 1_00_00
													__magic_name__      :       str       						= one_hot
							else:
													assert (
													    images.shape[0] == labels.shape[0]
													), F'images.shape: {images.shape} labels.shape: {labels.shape}'
													__magic_name__      :       Dict       						= images.shape[0]

													# Convert shape from [num examples, rows, columns, depth]
													# to [num examples, rows*columns] (assuming depth == 1)
													if reshape:
																			assert images.shape[3] == 1
																			__magic_name__      :       List[str]       						= images.reshape(
																			    images.shape[0]      ,       images.shape[1] * images.shape[2]			)
													if dtype == dtypes.floataa:
																			# Convert from [0, 255] -> [0.0, 1.0].
																			__magic_name__      :       List[str]       						= images.astype(numpy.floataa			)
																			__magic_name__      :       int       						= numpy.multiply(lowerCAmelCase__      ,       1.0 / 2_55.0			)
							__magic_name__      :       Optional[Any]       						= images
							__magic_name__      :       Optional[Any]       						= labels
							__magic_name__      :       str       						= 0
							__magic_name__      :       Union[str, Any]       						= 0
	@property
	def       __magic_name__    (    self			)							->				Dict:
							return self._images
	@property
	def       __magic_name__    (    self			)							->				Any:
							return self._labels
	@property
	def       __magic_name__    (    self			)							->				str:
							return self._num_examples
	@property
	def       __magic_name__    (    self			)							->				Any:
							return self._epochs_completed







	def       __magic_name__    (    self      ,       lowerCAmelCase__      ,       lowerCAmelCase__=False      ,       lowerCAmelCase__=True			)							->				int:
							if fake_data:
													__magic_name__      :       Tuple       						= [1] * 7_84
													__magic_name__      :       Dict       						= [1] + [0] * 9 if self.one_hot else 0
													return (
													    [fake_image for _ in range(lowerCAmelCase__			)],
													    [fake_label for _ in range(lowerCAmelCase__			)],
													)
							__magic_name__      :       Any       						= self._index_in_epoch
							# Shuffle for the first epoch
							if self._epochs_completed == 0 and start == 0 and shuffle:
													__magic_name__      :       Union[str, Any]       						= numpy.arange(self._num_examples			)
													numpy.random.shuffle(lowerCAmelCase__			)
													__magic_name__      :       List[Any]       						= self.images[perma]
													__magic_name__      :       int       						= self.labels[perma]
							# Go to the next epoch
							if start + batch_size > self._num_examples:
													# Finished epoch
													self._epochs_completed += 1
													# Get the rest examples in this epoch
													__magic_name__      :       Any       						= self._num_examples - start
													__magic_name__      :       List[Any]       						= self._images[start : self._num_examples]
													__magic_name__      :       Optional[Any]       						= self._labels[start : self._num_examples]
													# Shuffle the data
													if shuffle:
																			__magic_name__      :       Optional[Any]       						= numpy.arange(self._num_examples			)
																			numpy.random.shuffle(lowerCAmelCase__			)
																			__magic_name__      :       int       						= self.images[perm]
																			__magic_name__      :       Dict       						= self.labels[perm]
													# Start next epoch
													__magic_name__      :       Tuple       						= 0
													__magic_name__      :       Optional[int]       						= batch_size - rest_num_examples
													__magic_name__      :       List[str]       						= self._index_in_epoch
													__magic_name__      :       Dict       						= self._images[start:end]
													__magic_name__      :       int       						= self._labels[start:end]
													return (
													    numpy.concatenate((images_rest_part, images_new_part)      ,       axis=0			),
													    numpy.concatenate((labels_rest_part, labels_new_part)      ,       axis=0			),
													)
							else:
													self._index_in_epoch += batch_size
													__magic_name__      :       str       						= self._index_in_epoch
													return self._images[start:end], self._labels[start:end]



@deprecated(_A,   """Please write your own downloading logic."""			)
def    UpperCamelCase						(	_A,   _A,   _A			):






						"""simple docstring"""







						if not gfile.Exists(_A			):
												gfile.MakeDirs(_A			)
						__magic_name__      :       Optional[int]       						= os.path.join(_A,   _A			)
						if not gfile.Exists(_A			):
												urllib.request.urlretrieve(_A,   _A			)  # noqa: S310
												with gfile.GFile(_A			) as f:
																		__magic_name__      :       Any       						= f.size()
												print("""Successfully downloaded""",   _A,   _A,   """bytes."""			)
						return filepath

@deprecated(
    _A,   """Please use alternatives such as:""" """ tensorflow_datasets.load('mnist')"""			)
def    UpperCamelCase						(	_A,   _A=False,   _A=False,   _A=dtypes.floataa,   _A=True,   _A=5000,   _A=None,   _A=DEFAULT_SOURCE_URL,   ):






						"""simple docstring"""







						if fake_data:

												def fake():
																		return _DataSet(
																		    [],   [],   fake_data=_A,   one_hot=_A,   dtype=_A,   seed=_A			)

												__magic_name__      :       Tuple       						= fake()
												__magic_name__      :       List[Any]       						= fake()
												__magic_name__      :       Optional[int]       						= fake()
												return _Datasets(train=_A,   validation=_A,   test=_A			)

						if not source_url:  # empty string check
												__magic_name__      :       str       						= DEFAULT_SOURCE_URL

						__magic_name__      :       Optional[Any]       						= """train-images-idx3-ubyte.gz"""
						__magic_name__      :       Any       						= """train-labels-idx1-ubyte.gz"""
						__magic_name__      :       Optional[Any]       						= """t10k-images-idx3-ubyte.gz"""
						__magic_name__      :       Union[str, Any]       						= """t10k-labels-idx1-ubyte.gz"""

						__magic_name__      :       str       						= _maybe_download(
						    _A,   _A,   source_url + train_images_file			)
						with gfile.Open(_A,   """rb"""			) as f:
												__magic_name__      :       Optional[int]       						= _extract_images(_A			)

						__magic_name__      :       Any       						= _maybe_download(
						    _A,   _A,   source_url + train_labels_file			)
						with gfile.Open(_A,   """rb"""			) as f:
												__magic_name__      :       Dict       						= _extract_labels(_A,   one_hot=_A			)

						__magic_name__      :       Optional[int]       						= _maybe_download(
						    _A,   _A,   source_url + test_images_file			)
						with gfile.Open(_A,   """rb"""			) as f:
												__magic_name__      :       str       						= _extract_images(_A			)

						__magic_name__      :       Optional[int]       						= _maybe_download(
						    _A,   _A,   source_url + test_labels_file			)
						with gfile.Open(_A,   """rb"""			) as f:
												__magic_name__      :       str       						= _extract_labels(_A,   one_hot=_A			)

						if not 0 <= validation_size <= len(_A			):
												__magic_name__      :       List[str]       						= (
												    """Validation size should be between 0 and """
												    f'{len(_A			)}. Received: {validation_size}.'
												)
												raise ValueError(_A			)

						__magic_name__      :       Tuple       						= train_images[:validation_size]
						__magic_name__      :       int       						= train_labels[:validation_size]
						__magic_name__      :       Any       						= train_images[validation_size:]
						__magic_name__      :       Union[str, Any]       						= train_labels[validation_size:]

						__magic_name__      :       List[Any]       						= {"""dtype""": dtype, """reshape""": reshape, """seed""": seed}

						__magic_name__      :       Dict       						= _DataSet(_A,   _A,   **_A			)
						__magic_name__      :       Optional[int]       						= _DataSet(_A,   _A,   **_A			)
						__magic_name__      :       Dict       						= _DataSet(_A,   _A,   **_A			)

						return _Datasets(train=_A,   validation=_A,   test=_A			)








import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionAttendAndExcitePipeline,
    UNetaDConditionModel,
)
from diffusers.utils import load_numpy, skip_mps, slow
from diffusers.utils.testing_utils import require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


__magic_name__:					Union[str, Any]							=     False





@skip_mps
class 	snake_case__ (							_lowerCAmelCase						,  _lowerCAmelCase						,  _lowerCAmelCase						,  unittest.TestCase				):
	lowercase__						:					Optional[int]											=   StableDiffusionAttendAndExcitePipeline
	lowercase__						:					Tuple											=   False
	lowercase__						:					List[str]											=   TEXT_TO_IMAGE_PARAMS
	lowercase__						:					Dict											=   TEXT_TO_IMAGE_BATCH_PARAMS.union({'''token_indices'''}				)
	lowercase__						:					Union[str, Any]											=   TEXT_TO_IMAGE_IMAGE_PARAMS
	lowercase__						:					List[Any]											=   TEXT_TO_IMAGE_IMAGE_PARAMS
	@classmethod
	def       __magic_name__    (    cls			)							->				Tuple:
							super().setUpClass()
							torch.use_deterministic_algorithms(lowerCAmelCase__			)
	@classmethod
	def       __magic_name__    (    cls			)							->				Optional[Any]:
							super().tearDownClass()
							torch.use_deterministic_algorithms(lowerCAmelCase__			)
	def       __magic_name__    (    self			)							->				str:
							torch.manual_seed(0			)
							__magic_name__      :       Union[str, Any]       						= UNetaDConditionModel(
							    block_out_channels=(32, 64)      ,       layers_per_block=1      ,       sample_size=32      ,       in_channels=4      ,       out_channels=4      ,       down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")      ,       up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")      ,       cross_attention_dim=32      ,       attention_head_dim=(2, 4)      ,       use_linear_projection=lowerCAmelCase__      ,       )
							__magic_name__      :       List[Any]       						= DDIMScheduler(
							    beta_start=0.0_0_0_8_5      ,       beta_end=0.0_1_2      ,       beta_schedule="""scaled_linear"""      ,       clip_sample=lowerCAmelCase__      ,       set_alpha_to_one=lowerCAmelCase__      ,       )
							torch.manual_seed(0			)
							__magic_name__      :       List[Any]       						= 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      ,       sample_size=1_28      ,       )
							torch.manual_seed(0			)
							__magic_name__      :       List[str]       						= CLIPTextConfig(
							    bos_token_id=0      ,       eos_token_id=2      ,       hidden_size=32      ,       intermediate_size=37      ,       layer_norm_eps=1e-0_5      ,       num_attention_heads=4      ,       num_hidden_layers=5      ,       pad_token_id=1      ,       vocab_size=10_00      ,       hidden_act="""gelu"""      ,       projection_dim=5_12      ,       )
							__magic_name__      :       Any       						= CLIPTextModel(lowerCAmelCase__			)
							__magic_name__      :       Optional[int]       						= CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""			)

							__magic_name__      :       Optional[int]       						= {
							    """unet""": unet,
							    """scheduler""": scheduler,
							    """vae""": vae,
							    """text_encoder""": text_encoder,
							    """tokenizer""": tokenizer,
							    """safety_checker""": None,
							    """feature_extractor""": None,
							}

							return components
	def       __magic_name__    (    self      ,       lowerCAmelCase__      ,       lowerCAmelCase__=0			)							->				Optional[Any]:
							if str(lowerCAmelCase__			).startswith("""mps"""			):
													__magic_name__      :       int       						= torch.manual_seed(lowerCAmelCase__			)
							else:
													__magic_name__      :       int       						= torch.Generator(device=lowerCAmelCase__			).manual_seed(lowerCAmelCase__			)
							__magic_name__      :       Optional[Any]       						= {
							    """prompt""": """a cat and a frog""",
							    """token_indices""": [2, 5],
							    """generator""": generator,
							    """num_inference_steps""": 1,
							    """guidance_scale""": 6.0,
							    """output_type""": """numpy""",
							    """max_iter_to_alter""": 2,
							    """thresholds""": {0: 0.7},
							}
							return inputs
	def       __magic_name__    (    self			)							->				Dict:
							__magic_name__      :       int       						= """cpu"""

							__magic_name__      :       Union[str, Any]       						= self.get_dummy_components()
							__magic_name__      :       int       						= self.pipeline_class(**lowerCAmelCase__			)
							pipe.to(lowerCAmelCase__			)
							pipe.set_progress_bar_config(disable=lowerCAmelCase__			)

							__magic_name__      :       Union[str, Any]       						= self.get_dummy_inputs(lowerCAmelCase__			)
							__magic_name__      :       str       						= pipe(**lowerCAmelCase__			).images
							__magic_name__      :       Any       						= image[0, -3:, -3:, -1]

							self.assertEqual(image.shape      ,       (1, 64, 64, 3)			)
							__magic_name__      :       Dict       						= np.array(
							    [0.6_3_9_0_5_3_6_4, 0.6_2_8_9_7_3_0_7, 0.4_8_5_9_9_0_1_7, 0.5_1_3_3_6_2_4, 0.5_5_5_0_0_4_8, 0.4_5_7_6_9_5_1_6, 0.5_0_3_2_6_9_7_3, 0.5_0_2_3_1_3_9, 0.4_5_3_8_4_4_9_6]			)
							__magic_name__      :       Tuple       						= np.abs(image_slice.flatten() - expected_slice			).max()
							self.assertLessEqual(lowerCAmelCase__      ,       1e-3			)
	def       __magic_name__    (    self			)							->				List[Any]:
							super().test_cpu_offload_forward_pass(expected_max_diff=5e-4			)
	def       __magic_name__    (    self			)							->				Union[str, Any]:
							# NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
							self._test_inference_batch_consistent(batch_sizes=[1, 2]			)
	def       __magic_name__    (    self			)							->				int:
							self._test_inference_batch_single_identical(batch_size=2      ,       expected_max_diff=7e-4			)
	def       __magic_name__    (    self			)							->				List[str]:
							super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3			)
	def       __magic_name__    (    self			)							->				Any:
							super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5e-4			)
	def       __magic_name__    (    self			)							->				Dict:
							super().test_save_load_local(expected_max_difference=5e-4			)







	def       __magic_name__    (    self			)							->				List[Any]:
							super().test_save_load_optional_components(expected_max_difference=4e-4			)





@require_torch_gpu
@slow
class 	snake_case__ (							unittest.TestCase				):
	@classmethod
	def       __magic_name__    (    cls			)							->				Optional[int]:
							super().setUpClass()
							torch.use_deterministic_algorithms(lowerCAmelCase__			)
	@classmethod
	def       __magic_name__    (    cls			)							->				List[Any]:
							super().tearDownClass()
							torch.use_deterministic_algorithms(lowerCAmelCase__			)
	def       __magic_name__    (    self			)							->				Tuple:
							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()







	def       __magic_name__    (    self			)							->				Optional[Any]:
							__magic_name__      :       str       						= torch.manual_seed(51			)

							__magic_name__      :       Tuple       						= StableDiffusionAttendAndExcitePipeline.from_pretrained(
							    """CompVis/stable-diffusion-v1-4"""      ,       safety_checker=lowerCAmelCase__      ,       torch_dtype=torch.floataa			)
							pipe.to("""cuda"""			)

							__magic_name__      :       List[str]       						= """a painting of an elephant with glasses"""
							__magic_name__      :       Any       						= [5, 7]

							__magic_name__      :       List[Any]       						= pipe(
							    prompt=lowerCAmelCase__      ,       token_indices=lowerCAmelCase__      ,       guidance_scale=7.5      ,       generator=lowerCAmelCase__      ,       num_inference_steps=5      ,       max_iter_to_alter=5      ,       output_type="""numpy"""      ,       ).images[0]

							__magic_name__      :       Optional[int]       						= load_numpy(
							    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/attend-and-excite/elephant_glasses.npy"""			)
							assert np.abs((expected_image - image).max()			) < 5e-1
