

'''simple docstring'''





import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionSAGPipeline,
    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 		__SCREAMING_SNAKE_CASE       ( lowercase__	,       lowercase__	,       unittest.TestCase			):
				lowerCamelCase_							=						StableDiffusionSAGPipeline
				lowerCamelCase_							=						TEXT_TO_IMAGE_PARAMS
				lowerCamelCase_							=						TEXT_TO_IMAGE_BATCH_PARAMS
				lowerCamelCase_							=						TEXT_TO_IMAGE_IMAGE_PARAMS
				lowerCamelCase_							=						TEXT_TO_IMAGE_IMAGE_PARAMS
				lowerCamelCase_							=						False







				def    lowerCamelCase_  (					self    :		int      ):
										'''simple docstring'''
										torch.manual_seed(0      )
										lowercase   :       Tuple								=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		,				)
										lowercase   :       Union[str, Any]								=DDIMScheduler(
										    beta_start=0.0_00_85		,				beta_end=0.0_12		,				beta_schedule='''scaled_linear'''		,				clip_sample=UpperCAmelCase__		,				set_alpha_to_one=UpperCAmelCase__		,				)
										torch.manual_seed(0      )
										lowercase   :       Dict								=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      )
										lowercase   :       int								=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		,				)
										lowercase   :       str								=CLIPTextModel(UpperCAmelCase__      )
										lowercase   :       Tuple								=CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''      )

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







				def    lowerCamelCase_  (					self    :		Any		,				UpperCAmelCase__    :		Any		,				UpperCAmelCase__    :		List[str]=0      ):
										'''simple docstring'''
										if str(UpperCAmelCase__      ).startswith('''mps'''      ):
																lowercase   :       List[Any]								=torch.manual_seed(UpperCAmelCase__      )
										else:
																lowercase   :       Optional[Any]								=torch.Generator(device=UpperCAmelCase__      ).manual_seed(UpperCAmelCase__      )
										lowercase   :       Any								={
										    '''prompt''': '''.''',
										    '''generator''': generator,
										    '''num_inference_steps''': 2,
										    '''guidance_scale''': 1.0,
										    '''sag_scale''': 1.0,
										    '''output_type''': '''numpy''',
										}
										return inputs







				def    lowerCamelCase_  (					self    :		Optional[Any]      ):
										'''simple docstring'''
										super().test_inference_batch_single_identical(expected_max_diff=3E-3      )





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







				def    lowerCamelCase_  (					self    :		List[Any]      ):
										'''simple docstring'''
										# clean up the VRAM after each test
										super().tearDown()
										gc.collect()
										torch.cuda.empty_cache()







				def    lowerCamelCase_  (					self    :		Dict      ):
										'''simple docstring'''
										lowercase   :       int								=StableDiffusionSAGPipeline.from_pretrained('''CompVis/stable-diffusion-v1-4'''      )
										lowercase   :       Tuple								=sag_pipe.to(UpperCAmelCase__      )
										sag_pipe.set_progress_bar_config(disable=UpperCAmelCase__      )

										lowercase   :       str								='''.'''
										lowercase   :       int								=torch.manual_seed(0      )
										lowercase   :       Optional[int]								=sag_pipe(
										    [prompt]		,				generator=UpperCAmelCase__		,				guidance_scale=7.5		,				sag_scale=1.0		,				num_inference_steps=20		,				output_type='''np'''      )

										lowercase   :       str								=output.images

										lowercase   :       Union[str, Any]								=image[0, -3:, -3:, -1]

										assert image.shape == (1, 512, 512, 3)
										lowercase   :       Optional[int]								=np.array([0.15_68, 0.17_38, 0.16_95, 0.16_93, 0.15_07, 0.17_05, 0.15_47, 0.17_51, 0.19_49]      )

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







				def    lowerCamelCase_  (					self    :		str      ):
										'''simple docstring'''
										lowercase   :       Any								=StableDiffusionSAGPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base'''      )
										lowercase   :       Tuple								=sag_pipe.to(UpperCAmelCase__      )
										sag_pipe.set_progress_bar_config(disable=UpperCAmelCase__      )

										lowercase   :       Optional[int]								='''.'''
										lowercase   :       List[Any]								=torch.manual_seed(0      )
										lowercase   :       Optional[int]								=sag_pipe(
										    [prompt]		,				generator=UpperCAmelCase__		,				guidance_scale=7.5		,				sag_scale=1.0		,				num_inference_steps=20		,				output_type='''np'''      )

										lowercase   :       List[Any]								=output.images

										lowercase   :       Union[str, Any]								=image[0, -3:, -3:, -1]

										assert image.shape == (1, 512, 512, 3)
										lowercase   :       Any								=np.array([0.34_59, 0.28_76, 0.25_37, 0.30_02, 0.26_71, 0.21_60, 0.30_26, 0.22_62, 0.23_71]      )

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







				def    lowerCamelCase_  (					self    :		Optional[int]      ):
										'''simple docstring'''
										lowercase   :       List[str]								=StableDiffusionSAGPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base'''      )
										lowercase   :       List[str]								=sag_pipe.to(UpperCAmelCase__      )
										sag_pipe.set_progress_bar_config(disable=UpperCAmelCase__      )

										lowercase   :       List[str]								='''.'''
										lowercase   :       List[str]								=torch.manual_seed(0      )
										lowercase   :       List[Any]								=sag_pipe(
										    [prompt]		,				width=768		,				height=512		,				generator=UpperCAmelCase__		,				guidance_scale=7.5		,				sag_scale=1.0		,				num_inference_steps=20		,				output_type='''np'''		,				)

										lowercase   :       Any								=output.images

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








'''simple docstring'''





def 							_lowerCAmelCase (      __magic_name__	:    int      ,   __magic_name__	:    Optional[Any]	)							->     str:
						lowercase   :       Optional[Any]								=[0 for i in range(r + 1	)]
						# nc0 = 1
						lowercase   :       Optional[Any]								=1
						for i in range(1      ,   n + 1	):
												# to compute current row from previous row.
												lowercase   :       str								=min(__magic_name__      ,   __magic_name__	)
												while j > 0:
																		c[j] += c[j - 1]
																		j -= 1
						return c[r]







print(binomial_coefficient(n=10, r=5))





