

'''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


UpperCamelCase_							=					False





@skip_mps
class 		__SCREAMING_SNAKE_CASE       ( lowercase__	,       lowercase__	,       lowercase__	,       unittest.TestCase			):
				lowerCamelCase_							=						StableDiffusionAttendAndExcitePipeline
				lowerCamelCase_							=						False
				lowerCamelCase_							=						TEXT_TO_IMAGE_PARAMS
				lowerCamelCase_							=						TEXT_TO_IMAGE_BATCH_PARAMS.union({'token_indices'}			)
				lowerCamelCase_							=						TEXT_TO_IMAGE_IMAGE_PARAMS
				lowerCamelCase_							=						TEXT_TO_IMAGE_IMAGE_PARAMS







				@classmethod
				def    lowerCamelCase_  (					cls    :		Any      ):
										'''simple docstring'''
										super().setUpClass()
										torch.use_deterministic_algorithms(UpperCAmelCase__      )







				@classmethod
				def    lowerCamelCase_  (					cls    :		Optional[int]      ):
										'''simple docstring'''
										super().tearDownClass()
										torch.use_deterministic_algorithms(UpperCAmelCase__      )







				def    lowerCamelCase_  (					self    :		List[str]      ):
										'''simple docstring'''
										torch.manual_seed(0      )
										lowercase   :       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=UpperCAmelCase__		,				)
										lowercase   :       List[str]								=DDIMScheduler(
										    beta_start=0.0_00_85		,				beta_end=0.0_12		,				beta_schedule='''scaled_linear'''		,				clip_sample=UpperCAmelCase__		,				set_alpha_to_one=UpperCAmelCase__		,				)
										torch.manual_seed(0      )
										lowercase   :       List[str]								=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      )
										lowercase   :       int								=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		,				)
										lowercase   :       int								=CLIPTextModel(UpperCAmelCase__      )
										lowercase   :       List[Any]								=CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''      )

										lowercase   :       Optional[Any]								={
										    '''unet''': unet,
										    '''scheduler''': scheduler,
										    '''vae''': vae,
										    '''text_encoder''': text_encoder,
										    '''tokenizer''': tokenizer,
										    '''safety_checker''': None,
										    '''feature_extractor''': None,
										}

										return components







				def    lowerCamelCase_  (					self    :		int		,				UpperCAmelCase__    :		List[Any]		,				UpperCAmelCase__    :		Optional[int]=0      ):
										'''simple docstring'''
										if str(UpperCAmelCase__      ).startswith('''mps'''      ):
																lowercase   :       List[str]								=torch.manual_seed(UpperCAmelCase__      )
										else:
																lowercase   :       Dict								=torch.Generator(device=UpperCAmelCase__      ).manual_seed(UpperCAmelCase__      )
										lowercase   :       Optional[int]								={
										    '''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    lowerCamelCase_  (					self    :		Optional[Any]      ):
										'''simple docstring'''
										lowercase   :       int								='''cpu'''

										lowercase   :       Tuple								=self.get_dummy_components()
										lowercase   :       Optional[Any]								=self.pipeline_class(**UpperCAmelCase__      )
										pipe.to(UpperCAmelCase__      )
										pipe.set_progress_bar_config(disable=UpperCAmelCase__      )

										lowercase   :       int								=self.get_dummy_inputs(UpperCAmelCase__      )
										lowercase   :       Union[str, Any]								=pipe(**UpperCAmelCase__      ).images
										lowercase   :       Optional[Any]								=image[0, -3:, -3:, -1]

										self.assertEqual(image.shape		,				(1, 64, 64, 3)      )
										lowercase   :       Optional[Any]								=np.array(
										    [0.63_90_53_64, 0.62_89_73_07, 0.48_59_90_17, 0.5_13_36_24, 0.5_55_00_48, 0.45_76_95_16, 0.50_32_69_73, 0.5_02_31_39, 0.45_38_44_96]      )
										lowercase   :       List[Any]								=np.abs(image_slice.flatten() - expected_slice      ).max()
										self.assertLessEqual(UpperCAmelCase__		,				1E-3      )







				def    lowerCamelCase_  (					self    :		List[str]      ):
										'''simple docstring'''
										super().test_cpu_offload_forward_pass(expected_max_diff=5E-4      )







				def    lowerCamelCase_  (					self    :		List[str]      ):
										'''simple docstring'''
										self._test_inference_batch_consistent(batch_sizes=[1, 2]      )







				def    lowerCamelCase_  (					self    :		Any      ):
										'''simple docstring'''
										self._test_inference_batch_single_identical(batch_size=2		,				expected_max_diff=7E-4      )







				def    lowerCamelCase_  (					self    :		Optional[int]      ):
										'''simple docstring'''
										super().test_dict_tuple_outputs_equivalent(expected_max_difference=3E-3      )







				def    lowerCamelCase_  (					self    :		str      ):
										'''simple docstring'''
										super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5E-4      )







				def    lowerCamelCase_  (					self    :		List[str]      ):
										'''simple docstring'''
										super().test_save_load_local(expected_max_difference=5E-4      )







				def    lowerCamelCase_  (					self    :		List[str]      ):
										'''simple docstring'''
										super().test_save_load_optional_components(expected_max_difference=4E-4      )





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







				@classmethod
				def    lowerCamelCase_  (					cls    :		Tuple      ):
										'''simple docstring'''
										super().setUpClass()
										torch.use_deterministic_algorithms(UpperCAmelCase__      )







				@classmethod
				def    lowerCamelCase_  (					cls    :		Optional[Any]      ):
										'''simple docstring'''
										super().tearDownClass()
										torch.use_deterministic_algorithms(UpperCAmelCase__      )







				def    lowerCamelCase_  (					self    :		Optional[Any]      ):
										'''simple docstring'''
										super().tearDown()
										gc.collect()
										torch.cuda.empty_cache()







				def    lowerCamelCase_  (					self    :		Union[str, Any]      ):
										'''simple docstring'''
										lowercase   :       Dict								=torch.manual_seed(51      )

										lowercase   :       Any								=StableDiffusionAttendAndExcitePipeline.from_pretrained(
										    '''CompVis/stable-diffusion-v1-4'''		,				safety_checker=UpperCAmelCase__		,				torch_dtype=torch.floataa      )
										pipe.to('''cuda'''      )

										lowercase   :       Dict								='''a painting of an elephant with glasses'''
										lowercase   :       Optional[int]								=[5, 7]

										lowercase   :       Union[str, Any]								=pipe(
										    prompt=UpperCAmelCase__		,				token_indices=UpperCAmelCase__		,				guidance_scale=7.5		,				generator=UpperCAmelCase__		,				num_inference_steps=5		,				max_iter_to_alter=5		,				output_type='''numpy'''		,				).images[0]

										lowercase   :       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








'''simple docstring'''





from __future__ import annotations






def 							_lowerCAmelCase (      __magic_name__	:    list[list[int]]	)							->     bool:
						lowercase   :       str								=len(__magic_name__	)
						# We need to create solution object to save path.
						lowercase   :       int								=[[0 for _ in range(__magic_name__	)] for _ in range(__magic_name__	)]
						lowercase   :       List[Any]								=run_maze(__magic_name__      ,   0      ,   0      ,   __magic_name__	)
						if solved:
												print('''\n'''.join(str(__magic_name__	) for row in solutions	)	)
						else:
												print('''No solution exists!'''	)
						return solved






def 							_lowerCAmelCase (      __magic_name__	:    list[list[int]]      ,   __magic_name__	:    int      ,   __magic_name__	:    int      ,   __magic_name__	:    list[list[int]]	)							->     bool:
						lowercase   :       Optional[int]								=len(__magic_name__	)
						# Final check point.
						if i == j == (size - 1):
												lowercase   :       Optional[int]								=1
												return True

						lowercase   :       Optional[int]								=(not i < 0) and (not j < 0)  # Check lower bounds
						lowercase   :       Tuple								=(i < size) and (j < size)  # Check upper bounds

						if lower_flag and upper_flag:
												# check for already visited and block points.
												lowercase   :       Union[str, Any]								=(not solutions[i][j]) and (not maze[i][j])
												if block_flag:
																		# check visited
																		lowercase   :       Union[str, Any]								=1

																		# check for directions
																		if (
																		    run_maze(__magic_name__      ,   i + 1      ,   __magic_name__      ,   __magic_name__	)
																		    or run_maze(__magic_name__      ,   __magic_name__      ,   j + 1      ,   __magic_name__	)
																		    or run_maze(__magic_name__      ,   i - 1      ,   __magic_name__      ,   __magic_name__	)
																		    or run_maze(__magic_name__      ,   __magic_name__      ,   j - 1      ,   __magic_name__	)
																		):
																								return True

																		lowercase   :       str								=0
																		return False
						return False


if __name__ == "__main__":
							import doctest

							doctest.testmod()





