






"""simple docstring"""



import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    EulerAncestralDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionModelEditingPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

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


enable_full_determinism()






@skip_mps
class 				__SCREAMING_SNAKE_CASE    (					UpperCamelCase							,		UpperCamelCase							,		UpperCamelCase							,		unittest.TestCase		):
							snake_case_  =				StableDiffusionModelEditingPipeline
							snake_case_  =				TEXT_TO_IMAGE_PARAMS
							snake_case_  =				TEXT_TO_IMAGE_BATCH_PARAMS
							snake_case_  =				TEXT_TO_IMAGE_IMAGE_PARAMS
							snake_case_  =				TEXT_TO_IMAGE_IMAGE_PARAMS


							def     _UpperCamelCase							(      self   :    str				):
													'''simple docstring'''





													torch.manual_seed(0				)
													A__    :	List[Any]			=	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      ,     )
													A__    :	str			=	DDIMScheduler()
													torch.manual_seed(0				)
													A__    :	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      ,     )
													torch.manual_seed(0				)
													A__    :	List[Any]			=	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      ,     )
													A__    :	Dict			=	CLIPTextModel(snake_case				)
													A__    :	str			=	CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""				)

													A__    :	Tuple			=	{
													    """unet""": unet,
													    """scheduler""": scheduler,
													    """vae""": vae,
													    """text_encoder""": text_encoder,
													    """tokenizer""": tokenizer,
													    """safety_checker""": None,
													    """feature_extractor""": None,
													}
													return components


							def     _UpperCamelCase							(      self   :    Any      ,     snake_case   :    Optional[Any]      ,     snake_case   :    Optional[Any]=0				):
													'''simple docstring'''





													A__    :	List[Any]			=	torch.manual_seed(snake_case				)
													A__    :	Tuple			=	{
													    """prompt""": """A field of roses""",
													    """generator""": generator,
													    # Setting height and width to None to prevent OOMs on CPU.
													    """height""": None,
													    """width""": None,
													    """num_inference_steps""": 2,
													    """guidance_scale""": 6.0,
													    """output_type""": """numpy""",
													}
													return inputs


							def     _UpperCamelCase							(      self   :    Any				):
													'''simple docstring'''





													A__    :	int			=	"""cpu"""  # ensure determinism for the device-dependent torch.Generator
													A__    :	Union[str, Any]			=	self.get_dummy_components()
													A__    :	Union[str, Any]			=	StableDiffusionModelEditingPipeline(**snake_case				)
													A__    :	Dict			=	sd_pipe.to(snake_case				)
													sd_pipe.set_progress_bar_config(disable=snake_case				)

													A__    :	int			=	self.get_dummy_inputs(snake_case				)
													A__    :	Dict			=	sd_pipe(**snake_case				).images
													A__    :	List[Any]			=	image[0, -3:, -3:, -1]
													assert image.shape == (1, 64, 64, 3)

													A__    :	Union[str, Any]			=	np.array([0.4755, 0.5132, 0.4976, 0.3904, 0.3554, 0.4765, 0.5139, 0.5158, 0.4889]				)

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


							def     _UpperCamelCase							(      self   :    Union[str, Any]				):
													'''simple docstring'''





													A__    :	int			=	"""cpu"""  # ensure determinism for the device-dependent torch.Generator
													A__    :	Dict			=	self.get_dummy_components()
													A__    :	Optional[Any]			=	StableDiffusionModelEditingPipeline(**snake_case				)
													A__    :	Dict			=	sd_pipe.to(snake_case				)
													sd_pipe.set_progress_bar_config(disable=snake_case				)

													A__    :	Optional[Any]			=	self.get_dummy_inputs(snake_case				)
													A__    :	str			=	"""french fries"""
													A__    :	Dict			=	sd_pipe(**snake_case      ,     negative_prompt=snake_case				)
													A__    :	Optional[Any]			=	output.images
													A__    :	int			=	image[0, -3:, -3:, -1]

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

													A__    :	int			=	np.array([0.4992, 0.5101, 0.5004, 0.3949, 0.3604, 0.4735, 0.5216, 0.5204, 0.4913]				)

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


							def     _UpperCamelCase							(      self   :    Tuple				):
													'''simple docstring'''





													A__    :	Any			=	"""cpu"""  # ensure determinism for the device-dependent torch.Generator
													A__    :	List[str]			=	self.get_dummy_components()
													A__    :	Optional[Any]			=	EulerAncestralDiscreteScheduler(
													    beta_start=0.00085      ,     beta_end=0.012      ,     beta_schedule="""scaled_linear"""				)
													A__    :	int			=	StableDiffusionModelEditingPipeline(**snake_case				)
													A__    :	Optional[int]			=	sd_pipe.to(snake_case				)
													sd_pipe.set_progress_bar_config(disable=snake_case				)

													A__    :	Optional[int]			=	self.get_dummy_inputs(snake_case				)
													A__    :	Union[str, Any]			=	sd_pipe(**snake_case				).images
													A__    :	Optional[int]			=	image[0, -3:, -3:, -1]

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

													A__    :	List[Any]			=	np.array([0.4747, 0.5372, 0.4779, 0.4982, 0.5543, 0.4816, 0.5238, 0.4904, 0.5027]				)

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


							def     _UpperCamelCase							(      self   :    Tuple				):
													'''simple docstring'''





													A__    :	Any			=	"""cpu"""  # ensure determinism for the device-dependent torch.Generator
													A__    :	Optional[int]			=	self.get_dummy_components()
													A__    :	Dict			=	PNDMScheduler()
													A__    :	Tuple			=	StableDiffusionModelEditingPipeline(**snake_case				)
													A__    :	Optional[int]			=	sd_pipe.to(snake_case				)
													sd_pipe.set_progress_bar_config(disable=snake_case				)

													A__    :	Any			=	self.get_dummy_inputs(snake_case				)
													# the pipeline does not expect pndm so test if it raises error.
													with self.assertRaises(snake_case				):
																			A__    :	Union[str, Any]			=	sd_pipe(**snake_case				).images


							def     _UpperCamelCase							(      self   :    Tuple				):
													'''simple docstring'''





													super().test_inference_batch_single_identical(expected_max_diff=5e-3				)


							def     _UpperCamelCase							(      self   :    Optional[Any]				):
													'''simple docstring'''





													super().test_attention_slicing_forward_pass(expected_max_diff=5e-3				)






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


							def     _UpperCamelCase							(      self   :    Optional[Any]				):
													'''simple docstring'''





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


							def     _UpperCamelCase							(      self   :    Union[str, Any]      ,     snake_case   :    Any=0				):
													'''simple docstring'''





													A__    :	Union[str, Any]			=	torch.manual_seed(snake_case				)
													A__    :	Tuple			=	{
													    """prompt""": """A field of roses""",
													    """generator""": generator,
													    """num_inference_steps""": 3,
													    """guidance_scale""": 7.5,
													    """output_type""": """numpy""",
													}
													return inputs


							def     _UpperCamelCase							(      self   :    List[Any]				):
													'''simple docstring'''





													A__    :	Union[str, Any]			=	"""CompVis/stable-diffusion-v1-4"""
													A__    :	str			=	StableDiffusionModelEditingPipeline.from_pretrained(snake_case      ,     safety_checker=snake_case				)
													pipe.to(snake_case				)
													pipe.set_progress_bar_config(disable=snake_case				)
													pipe.enable_attention_slicing()

													A__    :	List[str]			=	self.get_inputs()
													A__    :	Optional[int]			=	pipe(**snake_case				).images
													A__    :	str			=	image[0, -3:, -3:, -1].flatten()

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

													A__    :	Any			=	np.array(
													    [0.6749496, 0.6386453, 0.51443267, 0.66094905, 0.61921215, 0.5491332, 0.5744417, 0.58075106, 0.5174658]				)

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

													# make sure image changes after editing
													pipe.edit_model("""A pack of roses"""      ,     """A pack of blue roses"""				)

													A__    :	Tuple			=	pipe(**snake_case				).images
													A__    :	str			=	image[0, -3:, -3:, -1].flatten()

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

													assert np.abs(expected_slice - image_slice				).max() > 1e-1


							def     _UpperCamelCase							(      self   :    Union[str, Any]				):
													'''simple docstring'''





													torch.cuda.empty_cache()
													torch.cuda.reset_max_memory_allocated()
													torch.cuda.reset_peak_memory_stats()

													A__    :	Optional[int]			=	"""CompVis/stable-diffusion-v1-4"""
													A__    :	Dict			=	DDIMScheduler.from_pretrained(snake_case      ,     subfolder="""scheduler"""				)
													A__    :	Optional[Any]			=	StableDiffusionModelEditingPipeline.from_pretrained(
													    snake_case      ,     scheduler=snake_case      ,     safety_checker=snake_case				)
													A__    :	Optional[Any]			=	pipe.to(snake_case				)
													pipe.set_progress_bar_config(disable=snake_case				)
													pipe.enable_attention_slicing(1				)
													pipe.enable_sequential_cpu_offload()

													A__    :	Dict			=	self.get_inputs()
													A__    :	Optional[Any]			=	pipe(**snake_case				)

													A__    :	str			=	torch.cuda.max_memory_allocated()
													# make sure that less than 4.4 GB is allocated
													assert mem_bytes < 4.4 * 10**9














"""simple docstring"""



from itertools import combinations, product




def   _lowerCAmelCase		(				UpperCAmelCase__							:       int,    UpperCAmelCase__							:       int,    UpperCAmelCase__							:       int,    UpperCAmelCase__							:       int   )		->bool:
						if xa == ya == 0 or xa == ya == 0:
												return False
						A__    :	List[str]			=	xa * xa + ya * ya
						A__    :	List[Any]			=	xa * xa + ya * ya
						A__    :	Optional[int]			=	(xa - xa) * (xa - xa) + (ya - ya) * (ya - ya)
						return (
						    a_square + b_square == c_square
						    or a_square + c_square == b_square
						    or b_square + c_square == a_square
						)




def   _lowerCAmelCase		(				UpperCAmelCase__							:       int = 5_0   )		->int:
						return sum(
						    1
						    for pta, pta in combinations(product(range(limit + 1   ),    repeat=2   ),    2   )
						    if is_right(*UpperCAmelCase__,    *UpperCAmelCase__   )   )


if __name__ == "__main__":
						print(F'{solution() = }')






