

'''simple docstring'''





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


A_	= False


@skip_mps
class  UpperCAmelCase (							UpperCAmelCase__  , UpperCAmelCase__  , UpperCAmelCase__  , unittest.TestCase    ):

		'''simple docstring'''






		SCREAMING_SNAKE_CASE_           =					StableDiffusionAttendAndExcitePipeline
		SCREAMING_SNAKE_CASE_           =					False
		SCREAMING_SNAKE_CASE_           =					TEXT_TO_IMAGE_PARAMS
		SCREAMING_SNAKE_CASE_           =					TEXT_TO_IMAGE_BATCH_PARAMS.union({'token_indices'}    )
		SCREAMING_SNAKE_CASE_           =					TEXT_TO_IMAGE_IMAGE_PARAMS
		SCREAMING_SNAKE_CASE_           =					TEXT_TO_IMAGE_IMAGE_PARAMS
		@classmethod
		def 			UpperCamelCase(					cls		)  ->     Optional[int]:






							'''simple docstring'''



							super().setUpClass()
							torch.use_deterministic_algorithms(SCREAMING_SNAKE_CASE_		)
		@classmethod
		def 			UpperCamelCase(					cls		)  ->     str:






							'''simple docstring'''



							super().tearDownClass()
							torch.use_deterministic_algorithms(SCREAMING_SNAKE_CASE_		)
		def 			UpperCamelCase(					self		)  ->     List[str]:






							'''simple docstring'''



							torch.manual_seed(0		)
							lowerCamelCase_  				=      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=SCREAMING_SNAKE_CASE_   ,			)
							lowerCamelCase_  				=      DDIMScheduler(
							    beta_start=0.00_085   ,			beta_end=0.012   ,			beta_schedule='scaled_linear'   ,			clip_sample=SCREAMING_SNAKE_CASE_   ,			set_alpha_to_one=SCREAMING_SNAKE_CASE_   ,			)
							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   ,			sample_size=128   ,			)
							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=1000   ,			hidden_act='gelu'   ,			projection_dim=512   ,			)
							lowerCamelCase_  				=      CLIPTextModel(SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'		)

							lowerCamelCase_  				=      {
							    'unet': unet,
							    'scheduler': scheduler,
							    'vae': vae,
							    'text_encoder': text_encoder,
							    'tokenizer': tokenizer,
							    'safety_checker': None,
							    'feature_extractor': None,
							}

							return components
		def 			UpperCamelCase(					self   ,			SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_=0		)  ->     int:






							'''simple docstring'''



							if str(SCREAMING_SNAKE_CASE_		).startswith('mps'		):
												lowerCamelCase_  				=      torch.manual_seed(SCREAMING_SNAKE_CASE_		)
							else:
												lowerCamelCase_  				=      torch.Generator(device=SCREAMING_SNAKE_CASE_		).manual_seed(SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      lowerCamelCase_  				=      {
							    '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 			UpperCamelCase(					self		)  ->     Tuple:






							'''simple docstring'''



							lowerCamelCase_  				=      'cpu'

							lowerCamelCase_  				=      self.get_dummy_components()
							lowerCamelCase_  				=      self.pipeline_class(**SCREAMING_SNAKE_CASE_		)
							pipe.to(SCREAMING_SNAKE_CASE_		)
							pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_		)

							lowerCamelCase_  				=      self.get_dummy_inputs(SCREAMING_SNAKE_CASE_		)
							lowerCamelCase_  				=      pipe(**SCREAMING_SNAKE_CASE_		).images
							lowerCamelCase_  				=      image[0, -3:, -3:, -1]

							self.assertEqual(image.shape   ,			(1, 64, 64, 3)		)
							lowerCamelCase_  				=      np.array(
							    [0.63_905_364, 0.62_897_307, 0.48_599_017, 0.5_133_624, 0.5_550_048, 0.45_769_516, 0.50_326_973, 0.5_023_139, 0.45_384_496]		)
							lowerCamelCase_  				=      np.abs(image_slice.flatten() - expected_slice		).max()
							self.assertLessEqual(SCREAMING_SNAKE_CASE_   ,			1E-3		)
		def 			UpperCamelCase(					self		)  ->     Dict:






							'''simple docstring'''



							super().test_cpu_offload_forward_pass(expected_max_diff=5E-4		)
		def 			UpperCamelCase(					self		)  ->     Optional[int]:






							'''simple docstring'''



							self._test_inference_batch_consistent(batch_sizes=[1, 2]		)
		def 			UpperCamelCase(					self		)  ->     str:






							'''simple docstring'''



							self._test_inference_batch_single_identical(batch_size=2   ,			expected_max_diff=7E-4		)
		def 			UpperCamelCase(					self		)  ->     List[str]:






							'''simple docstring'''



							super().test_dict_tuple_outputs_equivalent(expected_max_difference=3E-3		)
		def 			UpperCamelCase(					self		)  ->     int:






							'''simple docstring'''



							super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5E-4		)
		def 			UpperCamelCase(					self		)  ->     str:






							'''simple docstring'''



							super().test_save_load_local(expected_max_difference=5E-4		)






		def 			UpperCamelCase(					self		)  ->     Tuple:






							'''simple docstring'''



							super().test_save_load_optional_components(expected_max_difference=4E-4		)


@require_torch_gpu
@slow
class  UpperCAmelCase (							unittest.TestCase    ):

		'''simple docstring'''






		@classmethod
		def 			UpperCamelCase(					cls		)  ->     List[str]:






							'''simple docstring'''



							super().setUpClass()
							torch.use_deterministic_algorithms(SCREAMING_SNAKE_CASE_		)
		@classmethod
		def 			UpperCamelCase(					cls		)  ->     List[str]:






							'''simple docstring'''



							super().tearDownClass()
							torch.use_deterministic_algorithms(SCREAMING_SNAKE_CASE_		)
		def 			UpperCamelCase(					self		)  ->     int:






							'''simple docstring'''



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






		def 			UpperCamelCase(					self		)  ->     Optional[Any]:






							'''simple docstring'''



							lowerCamelCase_  				=      torch.manual_seed(51		)

							lowerCamelCase_  				=      StableDiffusionAttendAndExcitePipeline.from_pretrained(
							    'CompVis/stable-diffusion-v1-4'   ,			safety_checker=SCREAMING_SNAKE_CASE_   ,			torch_dtype=torch.floataa		)
							pipe.to('cuda'		)

							lowerCamelCase_  				=      'a painting of an elephant with glasses'
							lowerCamelCase_  				=      [5, 7]

							lowerCamelCase_  				=      pipe(
							    prompt=SCREAMING_SNAKE_CASE_   ,			token_indices=SCREAMING_SNAKE_CASE_   ,			guidance_scale=7.5   ,			generator=SCREAMING_SNAKE_CASE_   ,			num_inference_steps=5   ,			max_iter_to_alter=5   ,			output_type='numpy'   ,			).images[0]

							lowerCamelCase_  				=      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





"""simple docstring"""






def __magic_name__	(				_lowerCamelCase:		Tuple,					_lowerCamelCase:		Any			)					->						Optional[Any]:

	'''simple docstring'''




	lowerCAmelCase												=  [1]
	for i in range(2,					_lowerCamelCase			):
		factorials.append(factorials[-1] * i			)
	assert 0 <= k < factorials[-1] * n, "k out of bounds"

	lowerCAmelCase												=  []
	lowerCAmelCase												=  list(range(_lowerCamelCase			)			)

	# Find permutation
	while factorials:
		lowerCAmelCase												=  factorials.pop()
		lowerCAmelCase							,       lowerCAmelCase												=  divmod(_lowerCamelCase,					_lowerCamelCase			)
		permutation.append(elements[number]			)
		elements.remove(elements[number]			)
	permutation.append(elements[0]			)

	return permutation


if __name__ == "__main__":
					import doctest

					doctest.testmod()


