



"""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 			lowercase__			(      A,					A,					unittest.TestCase    ):
							'''simple docstring'''







							_UpperCAmelCase      				=					StableDiffusionSAGPipeline
							_UpperCAmelCase      				=					TEXT_TO_IMAGE_PARAMS
							_UpperCAmelCase      				=					TEXT_TO_IMAGE_BATCH_PARAMS
							_UpperCAmelCase      				=					TEXT_TO_IMAGE_IMAGE_PARAMS
							_UpperCAmelCase      				=					TEXT_TO_IMAGE_IMAGE_PARAMS
							_UpperCAmelCase      				=					False






							def        lowerCamelCase_   (  self						)			->							Tuple:
									torch.manual_seed(0						)
									_UpperCAmelCase							 =		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	,       )
									_UpperCAmelCase							 =		DDIMScheduler(
									    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							 =		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						)
									_UpperCAmelCase							 =		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	,       )
									_UpperCAmelCase							 =		CLIPTextModel(snake_case						)
									_UpperCAmelCase							 =		CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'						)

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






							def        lowerCamelCase_   (  self	,       snake_case	,       snake_case=0						)			->							Tuple:
									if str(snake_case						).startswith('mps'						):
											_UpperCAmelCase							 =		torch.manual_seed(snake_case						)
									else:
											_UpperCAmelCase							 =		torch.Generator(device=snake_case						).manual_seed(snake_case						)
									_UpperCAmelCase							 =		{
									    'prompt': '.',
									    'generator': generator,
									    'num_inference_steps': 2,
									    'guidance_scale': 1.0,
									    'sag_scale': 1.0,
									    'output_type': 'numpy',
									}
									return inputs






							def        lowerCamelCase_   (  self						)			->							str:
									super().test_inference_batch_single_identical(expected_max_diff=3E-3						)







@slow
@require_torch_gpu
class 			lowercase__			(      unittest.TestCase    ):
							'''simple docstring'''







							def        lowerCamelCase_   (  self						)			->							Optional[int]:
									# clean up the VRAM after each test
									super().tearDown()
									gc.collect()
									torch.cuda.empty_cache()






							def        lowerCamelCase_   (  self						)			->							Optional[Any]:
									_UpperCAmelCase							 =		StableDiffusionSAGPipeline.from_pretrained('CompVis/stable-diffusion-v1-4'						)
									_UpperCAmelCase							 =		sag_pipe.to(snake_case						)
									sag_pipe.set_progress_bar_config(disable=snake_case						)

									_UpperCAmelCase							 =		'.'
									_UpperCAmelCase							 =		torch.manual_seed(0						)
									_UpperCAmelCase							 =		sag_pipe(
									    [prompt]	,       generator=snake_case	,       guidance_scale=7.5	,       sag_scale=1.0	,       num_inference_steps=20	,       output_type='np'						)

									_UpperCAmelCase							 =		output.images

									_UpperCAmelCase							 =		image[0, -3:, -3:, -1]

									assert image.shape == (1, 512, 512, 3)
									_UpperCAmelCase							 =		np.array([0.1568, 0.1738, 0.1695, 0.1693, 0.1507, 0.1705, 0.1547, 0.1751, 0.1949]						)

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






							def        lowerCamelCase_   (  self						)			->							Optional[Any]:
									_UpperCAmelCase							 =		StableDiffusionSAGPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base'						)
									_UpperCAmelCase							 =		sag_pipe.to(snake_case						)
									sag_pipe.set_progress_bar_config(disable=snake_case						)

									_UpperCAmelCase							 =		'.'
									_UpperCAmelCase							 =		torch.manual_seed(0						)
									_UpperCAmelCase							 =		sag_pipe(
									    [prompt]	,       generator=snake_case	,       guidance_scale=7.5	,       sag_scale=1.0	,       num_inference_steps=20	,       output_type='np'						)

									_UpperCAmelCase							 =		output.images

									_UpperCAmelCase							 =		image[0, -3:, -3:, -1]

									assert image.shape == (1, 512, 512, 3)
									_UpperCAmelCase							 =		np.array([0.3459, 0.2876, 0.2537, 0.3002, 0.2671, 0.2160, 0.3026, 0.2262, 0.2371]						)

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






							def        lowerCamelCase_   (  self						)			->							Optional[Any]:
									_UpperCAmelCase							 =		StableDiffusionSAGPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base'						)
									_UpperCAmelCase							 =		sag_pipe.to(snake_case						)
									sag_pipe.set_progress_bar_config(disable=snake_case						)

									_UpperCAmelCase							 =		'.'
									_UpperCAmelCase							 =		torch.manual_seed(0						)
									_UpperCAmelCase							 =		sag_pipe(
									    [prompt]	,       width=768	,       height=512	,       generator=snake_case	,       guidance_scale=7.5	,       sag_scale=1.0	,       num_inference_steps=20	,       output_type='np'	,       )

									_UpperCAmelCase							 =		output.images

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







"""simple docstring"""





from itertools import permutations




def 	UpperCAmelCase     (		A	:						tuple       ):

		'''simple docstring'''


		if num[3] % 2 != 0:
				return False

		if (num[2] + num[3] + num[4]) % 3 != 0:
				return False

		if num[5] % 5 != 0:
				return False

		_UpperCAmelCase							 =		[7, 11, 13, 17]
		for i, test in enumerate(A       ):
				if (num[i + 4] * 100 + num[i + 5] * 10 + num[i + 6]) % test != 0:
						return False
		return True




def 	UpperCAmelCase     (		A	:						int = 10       ):

		'''simple docstring'''


		return sum(
		    int(''.join(map(A     ,				A       )       )       )
		    for num in permutations(range(A       )       )
		    if is_substring_divisible(A       )       )


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


