




"""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_  (       snake_case					, snake_case					, snake_case					, unittest.TestCase						):
		UpperCamelCase						 =StableDiffusionAttendAndExcitePipeline
		UpperCamelCase						 =False
		UpperCamelCase						 =TEXT_TO_IMAGE_PARAMS
		UpperCamelCase						 =TEXT_TO_IMAGE_BATCH_PARAMS.union({"token_indices"}						)
		UpperCamelCase						 =TEXT_TO_IMAGE_IMAGE_PARAMS
		UpperCamelCase						 =TEXT_TO_IMAGE_IMAGE_PARAMS
		@classmethod
		def      _lowerCamelCase				(		cls    )		->    Optional[int]:
					super().setUpClass()
					torch.use_deterministic_algorithms(UpperCamelCase_    )
		@classmethod
		def      _lowerCamelCase				(		cls    )		->    Union[str, Any]:
					super().tearDownClass()
					torch.use_deterministic_algorithms(UpperCamelCase_    )
		def      _lowerCamelCase				(		self    )		->    int:
					torch.manual_seed(0    )
					__lowercase       :   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       :   Any        =    DDIMScheduler(
					    beta_start=0.0_0_0_8_5							,		beta_end=0.0_1_2							,		beta_schedule='''scaled_linear'''							,		clip_sample=UpperCamelCase_							,		set_alpha_to_one=UpperCamelCase_							,		)
					torch.manual_seed(0    )
					__lowercase       :   Union[str, 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    )
					__lowercase       :   Tuple        =    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=10_00							,		hidden_act='''gelu'''							,		projection_dim=5_12							,		)
					__lowercase       :   str        =    CLIPTextModel(UpperCamelCase_    )
					__lowercase       :   Optional[Any]        =    CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''    )

					__lowercase       :   Union[str, Any]        =    {
					    'unet': unet,
					    'scheduler': scheduler,
					    'vae': vae,
					    'text_encoder': text_encoder,
					    'tokenizer': tokenizer,
					    'safety_checker': None,
					    'feature_extractor': None,
					}

					return components
		def      _lowerCamelCase				(		self							,		UpperCamelCase_							,		UpperCamelCase_=0    )		->    List[str]:







					if str(UpperCamelCase_    ).startswith('''mps'''    ):
								__lowercase       :   List[str]        =    torch.manual_seed(UpperCamelCase_    )
					else:
								__lowercase       :   Any        =    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    )		->    Union[str, Any]:
					__lowercase       :   Tuple        =    'cpu'

					__lowercase       :   Optional[int]        =    self.get_dummy_components()
					__lowercase       :   Dict        =    self.pipeline_class(**UpperCamelCase_    )
					pipe.to(UpperCamelCase_    )
					pipe.set_progress_bar_config(disable=UpperCamelCase_    )

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

					self.assertEqual(image.shape							,		(1, 64, 64, 3)    )
					__lowercase       :   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]    )
					__lowercase       :   Optional[int]        =    np.abs(image_slice.flatten() - expected_slice    ).max()
					self.assertLessEqual(UpperCamelCase_							,		1E-3    )
		def      _lowerCamelCase				(		self    )		->    List[Any]:
					super().test_cpu_offload_forward_pass(expected_max_diff=5E-4    )
		def      _lowerCamelCase				(		self    )		->    Union[str, Any]:
					self._test_inference_batch_consistent(batch_sizes=[1, 2]    )
		def      _lowerCamelCase				(		self    )		->    Optional[Any]:
					self._test_inference_batch_single_identical(batch_size=2							,		expected_max_diff=7E-4    )
		def      _lowerCamelCase				(		self    )		->    Tuple:
					super().test_dict_tuple_outputs_equivalent(expected_max_difference=3E-3    )
		def      _lowerCamelCase				(		self    )		->    Optional[Any]:
					super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5E-4    )
		def      _lowerCamelCase				(		self    )		->    Any:
					super().test_save_load_local(expected_max_difference=5E-4    )
		def      _lowerCamelCase				(		self    )		->    Dict:
					super().test_save_load_optional_components(expected_max_difference=4E-4    )


@require_torch_gpu
@slow
class    UpperCAmelCase_  (       unittest.TestCase						):
		@classmethod
		def      _lowerCamelCase				(		cls    )		->    Optional[Any]:
					super().setUpClass()
					torch.use_deterministic_algorithms(UpperCamelCase_    )
		@classmethod
		def      _lowerCamelCase				(		cls    )		->    int:
					super().tearDownClass()
					torch.use_deterministic_algorithms(UpperCamelCase_    )
		def      _lowerCamelCase				(		self    )		->    str:
					super().tearDown()
					gc.collect()
					torch.cuda.empty_cache()
		def      _lowerCamelCase				(		self    )		->    int:
					__lowercase       :   List[str]        =    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       :   Optional[int]        =    'a painting of an elephant with glasses'
					__lowercase       :   Any        =    [5, 7]

					__lowercase       :   Optional[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       :   str        =    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





from __future__ import annotations

lowerCamelCase__          =		list[list[int]]

# assigning initial values to the grid
lowerCamelCase__          =		[
    [3, 0, 6, 5, 0, 8, 4, 0, 0],
    [5, 2, 0, 0, 0, 0, 0, 0, 0],
    [0, 8, 7, 0, 0, 0, 0, 3, 1],
    [0, 0, 3, 0, 1, 0, 0, 8, 0],
    [9, 0, 0, 8, 6, 3, 0, 0, 5],
    [0, 5, 0, 0, 9, 0, 6, 0, 0],
    [1, 3, 0, 0, 0, 0, 2, 5, 0],
    [0, 0, 0, 0, 0, 0, 0, 7, 4],
    [0, 0, 5, 2, 0, 6, 3, 0, 0],
]

# a grid with no solution
lowerCamelCase__          =		[
    [5, 0, 6, 5, 0, 8, 4, 0, 3],
    [5, 2, 0, 0, 0, 0, 0, 0, 2],
    [1, 8, 7, 0, 0, 0, 0, 3, 1],
    [0, 0, 3, 0, 1, 0, 0, 8, 0],
    [9, 0, 0, 8, 6, 3, 0, 0, 5],
    [0, 5, 0, 0, 9, 0, 6, 0, 0],
    [1, 3, 0, 0, 0, 0, 2, 5, 0],
    [0, 0, 0, 0, 0, 0, 0, 7, 4],
    [0, 0, 5, 2, 0, 6, 3, 0, 0],
]
def  lowerCAmelCase__			(  SCREAMING_SNAKE_CASE_       ,							SCREAMING_SNAKE_CASE_       ,							SCREAMING_SNAKE_CASE_       ,							SCREAMING_SNAKE_CASE_     )				->		bool:
			for i in range(9     ):
						if grid[row][i] == n or grid[i][column] == n:
									return False

			for i in range(3     ):
						for j in range(3     ):
									if grid[(row - row % 3) + i][(column - column % 3) + j] == n:
												return False

			return True
def  lowerCAmelCase__			(  SCREAMING_SNAKE_CASE_     )				->		tuple[int, int] | None:
			for i in range(9     ):
						for j in range(9     ):
									if grid[i][j] == 0:
												return i, j
			return None
def  lowerCAmelCase__			(  SCREAMING_SNAKE_CASE_     )				->		Matrix | None:
			if location := find_empty_location(SCREAMING_SNAKE_CASE_     ):
						lowerCAmelCase__      ,				lowerCAmelCase__      :      Any         =		location
			else:
						# If the location is ``None``, then the grid is solved.
						return grid

			for digit in range(1       ,							10     ):
						if is_safe(SCREAMING_SNAKE_CASE_       ,							SCREAMING_SNAKE_CASE_       ,							SCREAMING_SNAKE_CASE_       ,							SCREAMING_SNAKE_CASE_     ):
									lowerCAmelCase__      :      Optional[Any]         =		digit

									if sudoku(SCREAMING_SNAKE_CASE_     ) is not None:
												return grid

									lowerCAmelCase__      :      List[Any]         =		0

			return None
def  lowerCAmelCase__			(  SCREAMING_SNAKE_CASE_     )				->		None:
			for row in grid:
						for cell in row:
									print(SCREAMING_SNAKE_CASE_       ,							end=' '     )
						print()


if __name__ == "__main__":
					# make a copy of grid so that you can compare with the unmodified grid
					for example_grid in (initial_grid, no_solution):
										print("""\nExample grid:\n""" + """=""" * 20)
										print_solution(example_grid)
										print("""\nExample grid solution:""")
										lowerCamelCase__          =		sudoku(example_grid)
										if solution is not None:
															print_solution(solution)
										else:
															print("""Cannot find a solution.""")