

'''simple docstring'''
import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMParallelScheduler,
    DDPMParallelScheduler,
    StableDiffusionParadigmsPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    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 PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()
class  _snake_case						(__SCREAMING_SNAKE_CASE       ,       __SCREAMING_SNAKE_CASE       ,       unittest.TestCase):
			__A   :     Dict          =StableDiffusionParadigmsPipeline
			__A   :     str          =TEXT_TO_IMAGE_PARAMS
			__A   :     Tuple          =TEXT_TO_IMAGE_BATCH_PARAMS
			__A   :     Optional[int]          =TEXT_TO_IMAGE_IMAGE_PARAMS
			__A   :     List[Any]          =TEXT_TO_IMAGE_IMAGE_PARAMS






			def 						UpperCamelCase__				(   self			):
				torch.manual_seed(0			)
				UpperCAmelCase_			:	str      =   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       ,attention_head_dim=(2, 4)       ,use_linear_projection=_snake_case       ,)
				UpperCAmelCase_			:	List[Any]      =   DDIMParallelScheduler(
				    beta_start=0.00085       ,beta_end=0.012       ,beta_schedule="scaled_linear"       ,clip_sample=_snake_case       ,set_alpha_to_one=_snake_case       ,)
				torch.manual_seed(0			)
				UpperCAmelCase_			:	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=1_28       ,)
				torch.manual_seed(0			)
				UpperCAmelCase_			:	Optional[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=10_00       ,hidden_act="gelu"       ,projection_dim=5_12       ,)
				UpperCAmelCase_			:	Tuple      =   CLIPTextModel(_snake_case			)
				UpperCAmelCase_			:	Optional[Any]      =   CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"			)

				UpperCAmelCase_			:	Union[str, Any]      =   {
				    "unet": unet,
				    "scheduler": scheduler,
				    "vae": vae,
				    "text_encoder": text_encoder,
				    "tokenizer": tokenizer,
				    "safety_checker": None,
				    "feature_extractor": None,
				}
				return components






			def 						UpperCamelCase__				(   self       ,_snake_case       ,_snake_case=0			):
				if str(_snake_case			).startswith("mps"			):
					UpperCAmelCase_			:	List[Any]      =   torch.manual_seed(_snake_case			)
				else:
					UpperCAmelCase_			:	List[str]      =   torch.Generator(device=_snake_case			).manual_seed(_snake_case			)
				UpperCAmelCase_			:	str      =   {
				    "prompt": "a photograph of an astronaut riding a horse",
				    "generator": generator,
				    "num_inference_steps": 10,
				    "guidance_scale": 6.0,
				    "output_type": "numpy",
				    "parallel": 3,
				    "debug": True,
				}
				return inputs






			def 						UpperCamelCase__				(   self			):
				UpperCAmelCase_			:	Any      =   "cpu"  # ensure determinism for the device-dependent torch.Generator
				UpperCAmelCase_			:	Dict      =   self.get_dummy_components()
				UpperCAmelCase_			:	Tuple      =   StableDiffusionParadigmsPipeline(**_snake_case			)
				UpperCAmelCase_			:	Dict      =   sd_pipe.to(_snake_case			)
				sd_pipe.set_progress_bar_config(disable=_snake_case			)

				UpperCAmelCase_			:	Optional[Any]      =   self.get_dummy_inputs(_snake_case			)
				UpperCAmelCase_			:	List[str]      =   sd_pipe(**_snake_case			).images
				UpperCAmelCase_			:	str      =   image[0, -3:, -3:, -1]
				assert image.shape == (1, 64, 64, 3)

				UpperCAmelCase_			:	Dict      =   np.array([0.4773, 0.5417, 0.4723, 0.4925, 0.5631, 0.4752, 0.5240, 0.4935, 0.5023]			)

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






			def 						UpperCamelCase__				(   self			):
				UpperCAmelCase_			:	List[str]      =   "cpu"  # ensure determinism for the device-dependent torch.Generator
				UpperCAmelCase_			:	Tuple      =   self.get_dummy_components()
				torch.manual_seed(0			)
				UpperCAmelCase_			:	Union[str, Any]      =   DDPMParallelScheduler()
				torch.manual_seed(0			)
				UpperCAmelCase_			:	Dict      =   StableDiffusionParadigmsPipeline(**_snake_case			)
				UpperCAmelCase_			:	List[str]      =   sd_pipe.to(_snake_case			)
				sd_pipe.set_progress_bar_config(disable=_snake_case			)

				UpperCAmelCase_			:	Union[str, Any]      =   self.get_dummy_inputs(_snake_case			)
				UpperCAmelCase_			:	List[Any]      =   sd_pipe(**_snake_case			).images
				UpperCAmelCase_			:	str      =   image[0, -3:, -3:, -1]
				assert image.shape == (1, 64, 64, 3)

				UpperCAmelCase_			:	int      =   np.array([0.3573, 0.4420, 0.4960, 0.4799, 0.3796, 0.3879, 0.4819, 0.4365, 0.4468]			)

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






			def 						UpperCamelCase__				(   self			):
				super().test_inference_batch_consistent(batch_sizes=[1, 2]			)






			def 						UpperCamelCase__				(   self			):
				super().test_inference_batch_single_identical(batch_size=2       ,expected_max_diff=3E-3			)






			def 						UpperCamelCase__				(   self			):
				UpperCAmelCase_			:	Any      =   "cpu"  # ensure determinism for the device-dependent torch.Generator
				UpperCAmelCase_			:	Optional[Any]      =   self.get_dummy_components()
				UpperCAmelCase_			:	Tuple      =   StableDiffusionParadigmsPipeline(**_snake_case			)
				UpperCAmelCase_			:	List[str]      =   sd_pipe.to(_snake_case			)
				sd_pipe.set_progress_bar_config(disable=_snake_case			)

				UpperCAmelCase_			:	Tuple      =   self.get_dummy_inputs(_snake_case			)
				UpperCAmelCase_			:	Any      =   "french fries"
				UpperCAmelCase_			:	Union[str, Any]      =   sd_pipe(**_snake_case       ,negative_prompt=_snake_case			)
				UpperCAmelCase_			:	Optional[Any]      =   output.images
				UpperCAmelCase_			:	Union[str, Any]      =   image[0, -3:, -3:, -1]

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

				UpperCAmelCase_			:	str      =   np.array([0.4771, 0.5420, 0.4683, 0.4918, 0.5636, 0.4725, 0.5230, 0.4923, 0.5015]			)

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




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






			def 						UpperCamelCase__				(   self			):
				super().tearDown()
				gc.collect()
				torch.cuda.empty_cache()






			def 						UpperCamelCase__				(   self       ,_snake_case=0			):
				UpperCAmelCase_			:	int      =   torch.Generator(device=_snake_case			).manual_seed(_snake_case			)
				UpperCAmelCase_			:	Tuple      =   {
				    "prompt": "a photograph of an astronaut riding a horse",
				    "generator": generator,
				    "num_inference_steps": 10,
				    "guidance_scale": 7.5,
				    "output_type": "numpy",
				    "parallel": 3,
				    "debug": True,
				}
				return inputs






			def 						UpperCamelCase__				(   self			):
				UpperCAmelCase_			:	int      =   "stabilityai/stable-diffusion-2-base"
				UpperCAmelCase_			:	Any      =   DDIMParallelScheduler.from_pretrained(_snake_case       ,subfolder="scheduler"			)
				UpperCAmelCase_			:	int      =   StableDiffusionParadigmsPipeline.from_pretrained(_snake_case       ,scheduler=_snake_case       ,safety_checker=_snake_case			)
				pipe.to(_snake_case			)
				pipe.set_progress_bar_config(disable=_snake_case			)
				pipe.enable_attention_slicing()

				UpperCAmelCase_			:	Optional[int]      =   self.get_inputs()
				UpperCAmelCase_			:	int      =   pipe(**_snake_case			).images
				UpperCAmelCase_			:	Any      =   image[0, -3:, -3:, -1].flatten()

				assert image.shape == (1, 5_12, 5_12, 3)

				UpperCAmelCase_			:	Union[str, Any]      =   np.array([0.9622, 0.9602, 0.9748, 0.9591, 0.9630, 0.9691, 0.9661, 0.9631, 0.9741]			)

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







'''simple docstring'''
from __future__ import annotations


def       a__    (  _SCREAMING_SNAKE_CASE					:    int							)			-> set[int]:


	"""simple docstring"""





	UpperCAmelCase_			:	Dict      =   {1}
	UpperCAmelCase_			:	int      =   [1]
	for _ in range(2     ,							depth + 1							):
		UpperCAmelCase_			:	Dict      =   [*previous_coefficients, 0]
		UpperCAmelCase_			:	Tuple      =   [0, *previous_coefficients]
		UpperCAmelCase_			:	Dict      =   []
		for x, y in zip(_SCREAMING_SNAKE_CASE     ,							_SCREAMING_SNAKE_CASE							):
			coefficients.add(x + y							)
			previous_coefficients.append(x + y							)
	return coefficients


def       a__    (  _SCREAMING_SNAKE_CASE					:    set[int]							)			-> set[int]:


	"""simple docstring"""





	UpperCAmelCase_			:	List[Any]      =   set()
	for number in unique_coefficients:
		UpperCAmelCase_			:	Tuple      =   2
		UpperCAmelCase_			:	Tuple      =   number
		while divisor**2 <= copy_number:
			UpperCAmelCase_			:	List[Any]      =   0
			while copy_number % divisor == 0:
				copy_number //= divisor
				multiplicity += 1
			if multiplicity >= 2:
				non_squarefrees.add(_SCREAMING_SNAKE_CASE							)
				break
			divisor += 1

	return unique_coefficients.difference(_SCREAMING_SNAKE_CASE							)


def       a__    (  _SCREAMING_SNAKE_CASE					:    int = 51							)			-> int:


	"""simple docstring"""





	UpperCAmelCase_			:	Optional[Any]      =   get_pascal_triangle_unique_coefficients(_SCREAMING_SNAKE_CASE							)
	UpperCAmelCase_			:	Union[str, Any]      =   get_squarefrees(_SCREAMING_SNAKE_CASE							)
	return sum(_SCREAMING_SNAKE_CASE							)


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




