
"""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  lowercase				(   lowercase__      ,lowercase__      ,unittest.TestCase		):
			lowercase			     =    StableDiffusionParadigmsPipeline
			lowercase			     =    TEXT_TO_IMAGE_PARAMS
			lowercase			     =    TEXT_TO_IMAGE_BATCH_PARAMS
			lowercase			     =    TEXT_TO_IMAGE_IMAGE_PARAMS
			lowercase			     =    TEXT_TO_IMAGE_IMAGE_PARAMS






			def 				UpperCAmelCase       (self     :  List[Any] )					->  List[str]:





				"""simple docstring"""


				torch.manual_seed(0 )
				lowerCAmelCase				       =     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=SCREAMING_SNAKE_CASE_			,)
				lowerCAmelCase				       =     DDIMParallelScheduler(
				    beta_start=0.0_00_85			,beta_end=0.0_12			,beta_schedule='''scaled_linear'''			,clip_sample=SCREAMING_SNAKE_CASE_			,set_alpha_to_one=SCREAMING_SNAKE_CASE_			,)
				torch.manual_seed(0 )
				lowerCAmelCase				       =     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 )
				lowerCAmelCase				       =     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=1_000			,hidden_act='''gelu'''			,projection_dim=512			,)
				lowerCAmelCase				       =     CLIPTextModel(SCREAMING_SNAKE_CASE_ )
				lowerCAmelCase				       =     CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''' )

				lowerCAmelCase				       =     {
				    '''unet''': unet,
				    '''scheduler''': scheduler,
				    '''vae''': vae,
				    '''text_encoder''': text_encoder,
				    '''tokenizer''': tokenizer,
				    '''safety_checker''': None,
				    '''feature_extractor''': None,
				}
				return components






			def 				UpperCAmelCase       (self     :  Any			,SCREAMING_SNAKE_CASE_     :  Any			,SCREAMING_SNAKE_CASE_     :  List[Any]=0 )					->  Dict:





				"""simple docstring"""


				if str(SCREAMING_SNAKE_CASE_ ).startswith('''mps''' ):
					lowerCAmelCase				       =     torch.manual_seed(SCREAMING_SNAKE_CASE_ )
				else:
					lowerCAmelCase				       =     torch.Generator(device=SCREAMING_SNAKE_CASE_ ).manual_seed(SCREAMING_SNAKE_CASE_ )
				lowerCAmelCase				       =     {
				    '''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     :  Tuple )					->  int:





				"""simple docstring"""


				lowerCAmelCase				       =     '''cpu'''  # ensure determinism for the device-dependent torch.Generator
				lowerCAmelCase				       =     self.get_dummy_components()
				lowerCAmelCase				       =     StableDiffusionParadigmsPipeline(**SCREAMING_SNAKE_CASE_ )
				lowerCAmelCase				       =     sd_pipe.to(SCREAMING_SNAKE_CASE_ )
				sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_ )

				lowerCAmelCase				       =     self.get_dummy_inputs(SCREAMING_SNAKE_CASE_ )
				lowerCAmelCase				       =     sd_pipe(**SCREAMING_SNAKE_CASE_ ).images
				lowerCAmelCase				       =     image[0, -3:, -3:, -1]
				assert image.shape == (1, 64, 64, 3)

				lowerCAmelCase				       =     np.array([0.47_73, 0.54_17, 0.47_23, 0.49_25, 0.56_31, 0.47_52, 0.52_40, 0.49_35, 0.50_23] )

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






			def 				UpperCAmelCase       (self     :  Union[str, Any] )					->  List[Any]:





				"""simple docstring"""


				lowerCAmelCase				       =     '''cpu'''  # ensure determinism for the device-dependent torch.Generator
				lowerCAmelCase				       =     self.get_dummy_components()
				torch.manual_seed(0 )
				lowerCAmelCase				       =     DDPMParallelScheduler()
				torch.manual_seed(0 )
				lowerCAmelCase				       =     StableDiffusionParadigmsPipeline(**SCREAMING_SNAKE_CASE_ )
				lowerCAmelCase				       =     sd_pipe.to(SCREAMING_SNAKE_CASE_ )
				sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_ )

				lowerCAmelCase				       =     self.get_dummy_inputs(SCREAMING_SNAKE_CASE_ )
				lowerCAmelCase				       =     sd_pipe(**SCREAMING_SNAKE_CASE_ ).images
				lowerCAmelCase				       =     image[0, -3:, -3:, -1]
				assert image.shape == (1, 64, 64, 3)

				lowerCAmelCase				       =     np.array([0.35_73, 0.44_20, 0.49_60, 0.47_99, 0.37_96, 0.38_79, 0.48_19, 0.43_65, 0.44_68] )

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






			def 				UpperCAmelCase       (self     :  str )					->  Union[str, Any]:





				"""simple docstring"""


				super().test_inference_batch_consistent(batch_sizes=[1, 2] )






			def 				UpperCAmelCase       (self     :  Any )					->  Optional[int]:





				"""simple docstring"""


				super().test_inference_batch_single_identical(batch_size=2			,expected_max_diff=3e-3 )






			def 				UpperCAmelCase       (self     :  Tuple )					->  Any:





				"""simple docstring"""


				lowerCAmelCase				       =     '''cpu'''  # ensure determinism for the device-dependent torch.Generator
				lowerCAmelCase				       =     self.get_dummy_components()
				lowerCAmelCase				       =     StableDiffusionParadigmsPipeline(**SCREAMING_SNAKE_CASE_ )
				lowerCAmelCase				       =     sd_pipe.to(SCREAMING_SNAKE_CASE_ )
				sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_ )

				lowerCAmelCase				       =     self.get_dummy_inputs(SCREAMING_SNAKE_CASE_ )
				lowerCAmelCase				       =     '''french fries'''
				lowerCAmelCase				       =     sd_pipe(**SCREAMING_SNAKE_CASE_			,negative_prompt=SCREAMING_SNAKE_CASE_ )
				lowerCAmelCase				       =     output.images
				lowerCAmelCase				       =     image[0, -3:, -3:, -1]

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

				lowerCAmelCase				       =     np.array([0.47_71, 0.54_20, 0.46_83, 0.49_18, 0.56_36, 0.47_25, 0.52_30, 0.49_23, 0.50_15] )

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





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






			def 				UpperCAmelCase       (self     :  Optional[Any] )					->  List[Any]:





				"""simple docstring"""


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






			def 				UpperCAmelCase       (self     :  Tuple			,SCREAMING_SNAKE_CASE_     :  List[str]=0 )					->  int:





				"""simple docstring"""


				lowerCAmelCase				       =     torch.Generator(device=SCREAMING_SNAKE_CASE_ ).manual_seed(SCREAMING_SNAKE_CASE_ )
				lowerCAmelCase				       =     {
				    '''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     :  Tuple )					->  Optional[Any]:





				"""simple docstring"""


				lowerCAmelCase				       =     '''stabilityai/stable-diffusion-2-base'''
				lowerCAmelCase				       =     DDIMParallelScheduler.from_pretrained(SCREAMING_SNAKE_CASE_			,subfolder='''scheduler''' )
				lowerCAmelCase				       =     StableDiffusionParadigmsPipeline.from_pretrained(SCREAMING_SNAKE_CASE_			,scheduler=SCREAMING_SNAKE_CASE_			,safety_checker=SCREAMING_SNAKE_CASE_ )
				pipe.to(SCREAMING_SNAKE_CASE_ )
				pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_ )
				pipe.enable_attention_slicing()

				lowerCAmelCase				       =     self.get_inputs()
				lowerCAmelCase				       =     pipe(**SCREAMING_SNAKE_CASE_ ).images
				lowerCAmelCase				       =     image[0, -3:, -3:, -1].flatten()

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

				lowerCAmelCase				       =     np.array([0.96_22, 0.96_02, 0.97_48, 0.95_91, 0.96_30, 0.96_91, 0.96_61, 0.96_31, 0.97_41] )

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




"""simple docstring"""






def __magic_name__  (							_lowerCamelCase:		int,				_lowerCamelCase:		int )				->	int:

	'''simple docstring'''




	lowerCAmelCase				       =     1.0
	for i in range(1,				r + 1 ):
		ret *= (n + 1 - i) / i
	return round(_lowerCamelCase )




def __magic_name__  (							_lowerCamelCase:		int )				->	int:

	'''simple docstring'''




	return choose(8 + n,				_lowerCamelCase ) + choose(9 + n,				_lowerCamelCase ) - 10




def __magic_name__  (							_lowerCamelCase:		int )				->	int:

	'''simple docstring'''




	return sum(non_bouncy_exact(_lowerCamelCase ) for i in range(1,				n + 1 ) )




def __magic_name__  (							_lowerCamelCase:		int = 100 )				->	int:

	'''simple docstring'''




	return non_bouncy_upto(_lowerCamelCase )


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


