'''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    ):







    """simple docstring"""





    A			:  Optional[Any]            =       StableDiffusionParadigmsPipeline
    A			:  Optional[Any]            =       TEXT_TO_IMAGE_PARAMS
    A			:  Union[str, Any]            =       TEXT_TO_IMAGE_BATCH_PARAMS
    A			:  int            =       TEXT_TO_IMAGE_IMAGE_PARAMS
    A			:  List[Any]            =       TEXT_TO_IMAGE_IMAGE_PARAMS





    def 					SCREAMING_SNAKE_CASE_			( self			:		Tuple):


         """simple docstring"""







         torch.manual_seed(0)
         a :				Optional[int]				=      UNetaDConditionModel(
             block_out_channels=(3_2, 6_4)				,				layers_per_block=2				,				sample_size=3_2				,				in_channels=4				,				out_channels=4				,				down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')				,				up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')				,				cross_attention_dim=3_2				,				attention_head_dim=(2, 4)				,				use_linear_projection=_UpperCamelCase				,				)
         a :				Union[str, Any]				=      DDIMParallelScheduler(
             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)
         a :				List[Any]				=      AutoencoderKL(
             block_out_channels=[3_2, 6_4]				,				in_channels=3				,				out_channels=3				,				down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']				,				up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']				,				latent_channels=4				,				sample_size=1_2_8				,				)
         torch.manual_seed(0)
         a :				Dict				=      CLIPTextConfig(
             bos_token_id=0				,				eos_token_id=2				,				hidden_size=3_2				,				intermediate_size=3_7				,				layer_norm_eps=1e-05				,				num_attention_heads=4				,				num_hidden_layers=5				,				pad_token_id=1				,				vocab_size=1_0_0_0				,				hidden_act='gelu'				,				projection_dim=5_1_2				,				)
         a :				Dict				=      CLIPTextModel(_UpperCamelCase)
         a :				Any				=      CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

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





    def 					SCREAMING_SNAKE_CASE_			( self			:		Any				,				UpperCAmelCase_			:		List[str]				,				UpperCAmelCase_			:		Any=0):


         """simple docstring"""







         if str(_UpperCamelCase).startswith('mps'):
              a :				List[str]				=      torch.manual_seed(_UpperCamelCase)
         else:
              a :				Optional[Any]				=      torch.Generator(device=_UpperCamelCase).manual_seed(_UpperCamelCase)
         a :				Tuple				=      {
             'prompt': 'a photograph of an astronaut riding a horse',
             'generator': generator,
             'num_inference_steps': 1_0,
             'guidance_scale': 6.0,
             'output_type': 'numpy',
             'parallel': 3,
             'debug': True,
         }
         return inputs





    def 					SCREAMING_SNAKE_CASE_			( self			:		Optional[Any]):


         """simple docstring"""







         a :				str				=      'cpu'  # ensure determinism for the device-dependent torch.Generator
         a :				Tuple				=      self.get_dummy_components()
         a :				Tuple				=      StableDiffusionParadigmsPipeline(**_UpperCamelCase)
         a :				List[str]				=      sd_pipe.to(_UpperCamelCase)
         sd_pipe.set_progress_bar_config(disable=_UpperCamelCase)

         a :				List[Any]				=      self.get_dummy_inputs(_UpperCamelCase)
         a :				Any				=      sd_pipe(**_UpperCamelCase).images
         a :				str				=      image[0, -3:, -3:, -1]
         assert image.shape == (1, 6_4, 6_4, 3)

         a :				str				=      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 					SCREAMING_SNAKE_CASE_			( self			:		Optional[Any]):


         """simple docstring"""







         a :				Optional[int]				=      'cpu'  # ensure determinism for the device-dependent torch.Generator
         a :				Optional[Any]				=      self.get_dummy_components()
         torch.manual_seed(0)
         a :				int				=      DDPMParallelScheduler()
         torch.manual_seed(0)
         a :				int				=      StableDiffusionParadigmsPipeline(**_UpperCamelCase)
         a :				Optional[int]				=      sd_pipe.to(_UpperCamelCase)
         sd_pipe.set_progress_bar_config(disable=_UpperCamelCase)

         a :				Dict				=      self.get_dummy_inputs(_UpperCamelCase)
         a :				Optional[int]				=      sd_pipe(**_UpperCamelCase).images
         a :				Any				=      image[0, -3:, -3:, -1]
         assert image.shape == (1, 6_4, 6_4, 3)

         a :				Any				=      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 					SCREAMING_SNAKE_CASE_			( self			:		Tuple):


         """simple docstring"""







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





    def 					SCREAMING_SNAKE_CASE_			( self			:		List[Any]):


         """simple docstring"""







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







    def 					SCREAMING_SNAKE_CASE_			( self			:		List[Any]):


         """simple docstring"""







         a :				Tuple				=      'cpu'  # ensure determinism for the device-dependent torch.Generator
         a :				Optional[Any]				=      self.get_dummy_components()
         a :				Optional[Any]				=      StableDiffusionParadigmsPipeline(**_UpperCamelCase)
         a :				List[Any]				=      sd_pipe.to(_UpperCamelCase)
         sd_pipe.set_progress_bar_config(disable=_UpperCamelCase)

         a :				str				=      self.get_dummy_inputs(_UpperCamelCase)
         a :				Optional[int]				=      'french fries'
         a :				str				=      sd_pipe(**_UpperCamelCase				,				negative_prompt=_UpperCamelCase)
         a :				Optional[int]				=      output.images
         a :				List[str]				=      image[0, -3:, -3:, -1]

         assert image.shape == (1, 6_4, 6_4, 3)

         a :				Optional[Any]				=      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    UpperCamelCase (    unittest.TestCase    ):







    """simple docstring"""





    def 					SCREAMING_SNAKE_CASE_			( self			:		List[str]):


         """simple docstring"""







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





    def 					SCREAMING_SNAKE_CASE_			( self			:		Optional[Any]				,				UpperCAmelCase_			:		int=0):


         """simple docstring"""







         a :				List[Any]				=      torch.Generator(device=_UpperCamelCase).manual_seed(_UpperCamelCase)
         a :				List[Any]				=      {
             'prompt': 'a photograph of an astronaut riding a horse',
             'generator': generator,
             'num_inference_steps': 1_0,
             'guidance_scale': 7.5,
             'output_type': 'numpy',
             'parallel': 3,
             'debug': True,
         }
         return inputs







    def 					SCREAMING_SNAKE_CASE_			( self			:		Dict):


         """simple docstring"""







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

         a :				List[Any]				=      self.get_inputs()
         a :				Dict				=      pipe(**_UpperCamelCase).images
         a :				int				=      image[0, -3:, -3:, -1].flatten()

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

         a :				int				=      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


import math





def 		__lowerCamelCase							(UpperCAmelCase__   :							int     ):

					if 1 < number < 4:
										# 2 and 3 are primes
										return True
					elif number < 2 or number % 2 == 0 or number % 3 == 0:
										# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
										return False

					# All primes number are in format of 6k +/- 1
					for i in range(5					,       int(math.sqrt(UpperCAmelCase__     ) + 1     )					,       6     ):
										if number % i == 0 or number % (i + 2) == 0:
															return False
					return True





def 		__lowerCamelCase							(UpperCAmelCase__   :							int = 2_0_0_0_0_0_0     ):
					return sum(num for num in range(3					,       UpperCAmelCase__					,       2     ) if is_prime(UpperCAmelCase__     )     ) + 2 if n > 2 else 0


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




