

"""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       _UpperCAmelCase     (						__a      ,       __a      ,       unittest.TestCase):
			__a	:    Dict			   =							StableDiffusionParadigmsPipeline
			__a	:    str			   =							TEXT_TO_IMAGE_PARAMS
			__a	:    List[str]			   =							TEXT_TO_IMAGE_BATCH_PARAMS
			__a	:    Optional[Any]			   =							TEXT_TO_IMAGE_IMAGE_PARAMS
			__a	:    str			   =							TEXT_TO_IMAGE_IMAGE_PARAMS
			def 							__snake_case	(						self       )      ->      Optional[int]:






				'''simple docstring'''







				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=_A ,						)
				_UpperCAmelCase      :							List[Any]       =   DDIMParallelScheduler(
				    beta_start=0.00085 ,						beta_end=0.012 ,						beta_schedule="""scaled_linear""" ,						clip_sample=_A ,						set_alpha_to_one=_A ,						)
				torch.manual_seed(0       )
				_UpperCAmelCase      :							Tuple       =   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      :							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=10_00 ,						hidden_act="""gelu""" ,						projection_dim=5_12 ,						)
				_UpperCAmelCase      :							str       =   CLIPTextModel(_A       )
				_UpperCAmelCase      :							Optional[Any]       =   CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""       )

				_UpperCAmelCase      :							int       =   {
				    """unet""": unet,
				    """scheduler""": scheduler,
				    """vae""": vae,
				    """text_encoder""": text_encoder,
				    """tokenizer""": tokenizer,
				    """safety_checker""": None,
				    """feature_extractor""": None,
				}
				return components
			def 							__snake_case	(						self ,						_A ,						_A=0       )      ->      str:






				'''simple docstring'''







				if str(_A       ).startswith("""mps"""       ):
					_UpperCAmelCase      :							str       =   torch.manual_seed(_A       )
				else:
					_UpperCAmelCase      :							Any       =   torch.Generator(device=_A       ).manual_seed(_A       )
				_UpperCAmelCase      :							Union[str, Any]       =   {
				    """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 							__snake_case	(						self       )      ->      Any:






				'''simple docstring'''







				_UpperCAmelCase      :							str       =   """cpu"""  # ensure determinism for the device-dependent torch.Generator
				_UpperCAmelCase      :							Optional[Any]       =   self.get_dummy_components()
				_UpperCAmelCase      :							int       =   StableDiffusionParadigmsPipeline(**_A       )
				_UpperCAmelCase      :							Tuple       =   sd_pipe.to(_A       )
				sd_pipe.set_progress_bar_config(disable=_A       )

				_UpperCAmelCase      :							List[str]       =   self.get_dummy_inputs(_A       )
				_UpperCAmelCase      :							int       =   sd_pipe(**_A       ).images
				_UpperCAmelCase      :							List[Any]       =   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 							__snake_case	(						self       )      ->      List[Any]:






				'''simple docstring'''







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

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

				_UpperCAmelCase      :							Any       =   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 							__snake_case	(						self       )      ->      Tuple:






				'''simple docstring'''







				super().test_inference_batch_consistent(batch_sizes=[1, 2]       )
			def 							__snake_case	(						self       )      ->      Optional[Any]:






				'''simple docstring'''







				super().test_inference_batch_single_identical(batch_size=2 ,						expected_max_diff=3e-3       )
			def 							__snake_case	(						self       )      ->      Any:






				'''simple docstring'''







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

				_UpperCAmelCase      :							Union[str, Any]       =   self.get_dummy_inputs(_A       )
				_UpperCAmelCase      :							Dict       =   """french fries"""
				_UpperCAmelCase      :							List[Any]       =   sd_pipe(**_A ,						negative_prompt=_A       )
				_UpperCAmelCase      :							str       =   output.images
				_UpperCAmelCase      :							List[str]       =   image[0, -3:, -3:, -1]

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

				_UpperCAmelCase      :							Any       =   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       _UpperCAmelCase     (						unittest.TestCase):
			def 							__snake_case	(						self       )      ->      Optional[int]:






				'''simple docstring'''







				super().tearDown()
				gc.collect()
				torch.cuda.empty_cache()
			def 							__snake_case	(						self ,						_A=0       )      ->      str:






				'''simple docstring'''







				_UpperCAmelCase      :							List[Any]       =   torch.Generator(device=_A       ).manual_seed(_A       )
				_UpperCAmelCase      :							Union[str, Any]       =   {
				    """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 							__snake_case	(						self       )      ->      List[str]:






				'''simple docstring'''







				_UpperCAmelCase      :							Tuple       =   """stabilityai/stable-diffusion-2-base"""
				_UpperCAmelCase      :							List[Any]       =   DDIMParallelScheduler.from_pretrained(_A ,						subfolder="""scheduler"""       )
				_UpperCAmelCase      :							Tuple       =   StableDiffusionParadigmsPipeline.from_pretrained(_A ,						scheduler=_A ,						safety_checker=_A       )
				pipe.to(_A       )
				pipe.set_progress_bar_config(disable=_A       )
				pipe.enable_attention_slicing()

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

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

				_UpperCAmelCase      :							List[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"""






def  UpperCamelCase   (     _lowerCAmelCase       :  float,					_lowerCAmelCase       :  float,					_lowerCAmelCase       :  float	)			->     float:
	if mass < 0:
		raise ValueError("""The mass of the body cannot be negative"""	)
	if radius <= 0:
		raise ValueError("""The radius is always a positive non zero integer"""	)
	return (mass * (velocity) ** 2) / radius


if __name__ == "__main__":
						import doctest

						doctest.testmod(verbose=True)





