



import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DiffusionPipeline,
    EulerDiscreteScheduler,
    StableDiffusionXLPipeline,
    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 			__snake_case   ( SCREAMING_SNAKE_CASE      ,SCREAMING_SNAKE_CASE      ,unittest.TestCase):







							'''simple docstring'''






							UpperCamelCase__					:   List[str]       =       StableDiffusionXLPipeline
							UpperCamelCase__					:   int       =       TEXT_TO_IMAGE_PARAMS
							UpperCamelCase__					:   int       =       TEXT_TO_IMAGE_BATCH_PARAMS
							UpperCamelCase__					:   int       =       TEXT_TO_IMAGE_IMAGE_PARAMS
							UpperCamelCase__					:   Any       =       TEXT_TO_IMAGE_IMAGE_PARAMS


							def _a   (				self		):
											torch.manual_seed(0		)
											a__					   =		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""")	,	attention_head_dim=(2, 4)	,	use_linear_projection=a_	,	addition_embed_type="""text_time"""	,	addition_time_embed_dim=8	,	transformer_layers_per_block=(1, 2)	,	projection_class_embeddings_input_dim=80	,	cross_attention_dim=64	,	)
											a__					   =		EulerDiscreteScheduler(
											    beta_start=0.00_085	,	beta_end=0.012	,	steps_offset=1	,	beta_schedule="""scaled_linear"""	,	timestep_spacing="""leading"""	,	)
											torch.manual_seed(0		)
											a__					   =		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		)
											a__					   =		CLIPTextConfig(
											    bos_token_id=0	,	eos_token_id=2	,	hidden_size=32	,	intermediate_size=37	,	layer_norm_eps=1E-0_5	,	num_attention_heads=4	,	num_hidden_layers=5	,	pad_token_id=1	,	vocab_size=1_000	,	hidden_act="""gelu"""	,	projection_dim=32	,	)
											a__					   =		CLIPTextModel(a_		)
											a__					   =		CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""	,	local_files_only=a_		)

											a__					   =		CLIPTextModelWithProjection(a_		)
											a__					   =		CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""	,	local_files_only=a_		)

											a__					   =		{
											    """unet""": unet,
											    """scheduler""": scheduler,
											    """vae""": vae,
											    """text_encoder""": text_encoder,
											    """tokenizer""": tokenizer,
											    """text_encoder_2""": text_encoder_a,
											    """tokenizer_2""": tokenizer_a,
											    # "safety_checker": None,
											    # "feature_extractor": None,
											}
											return components


							def _a   (				self	,	a_	,	a_=0		):
											if str(a_		).startswith("""mps"""		):
															a__					   =		torch.manual_seed(a_		)
											else:
															a__					   =		torch.Generator(device=a_		).manual_seed(a_		)
											a__					   =		{
											    """prompt""": """A painting of a squirrel eating a burger""",
											    """generator""": generator,
											    """num_inference_steps""": 2,
											    """guidance_scale""": 5.0,
											    """output_type""": """numpy""",
											}
											return inputs


							def _a   (				self		):
											a__					   =		"""cpu"""  # ensure determinism for the device-dependent torch.Generator
											a__					   =		self.get_dummy_components()
											a__					   =		StableDiffusionXLPipeline(**a_		)
											a__					   =		sd_pipe.to(a_		)
											sd_pipe.set_progress_bar_config(disable=a_		)

											a__					   =		self.get_dummy_inputs(a_		)
											a__					   =		sd_pipe(**a_		).images
											a__					   =		image[0, -3:, -3:, -1]

											assert image.shape == (1, 64, 64, 3)
											a__					   =		np.array([0.5_873, 0.6_128, 0.4_797, 0.5_122, 0.5_674, 0.4_639, 0.5_227, 0.5_149, 0.4_747]		)

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


							def _a   (				self		):
											a__					   =		self.get_dummy_components()
											a__					   =		StableDiffusionXLPipeline(**a_		)
											a__					   =		sd_pipe.to(a_		)
											a__					   =		sd_pipe.to(a_		)
											sd_pipe.set_progress_bar_config(disable=a_		)

											# forward without prompt embeds
											a__					   =		self.get_dummy_inputs(a_		)
											a__					   =		3 * ["""this is a negative prompt"""]
											a__					   =		negative_prompt
											a__					   =		3 * [inputs["""prompt"""]]

											a__					   =		sd_pipe(**a_		)
											a__					   =		output.images[0, -3:, -3:, -1]

											# forward with prompt embeds
											a__					   =		self.get_dummy_inputs(a_		)
											a__					   =		3 * ["""this is a negative prompt"""]
											a__					   =		3 * [inputs.pop("""prompt"""		)]

											(
											    (
											    a__
											)   ,      (
											    a__
											)   ,      (
											    a__
											)   ,      (
											    a__
											)   ,      
											)					   =		sd_pipe.encode_prompt(a_	,	negative_prompt=a_		)

											a__					   =		sd_pipe(
											    **a_	,	prompt_embeds=a_	,	negative_prompt_embeds=a_	,	pooled_prompt_embeds=a_	,	negative_pooled_prompt_embeds=a_	,	)
											a__					   =		output.images[0, -3:, -3:, -1]

											# make sure that it's equal
											assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()		).max() < 1E-4


							def _a   (				self		):
											super().test_attention_slicing_forward_pass(expected_max_diff=3E-3		)







							def _a   (				self		):
											super().test_inference_batch_single_identical(expected_max_diff=3E-3		)




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







							'''simple docstring'''






							def _a   (				self		):
											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()


							def _a   (				self	,	a_	,	a_="cpu"	,	a_=torch.floataa	,	a_=0		):
											a__					   =		torch.Generator(device=a_		).manual_seed(a_		)
											a__					   =		np.random.RandomState(a_		).standard_normal((1, 4, 64, 64)		)
											a__					   =		torch.from_numpy(a_		).to(device=a_	,	dtype=a_		)
											a__					   =		{
											    """prompt""": """a photograph of an astronaut riding a horse""",
											    """latents""": latents,
											    """generator""": generator,
											    """num_inference_steps""": 3,
											    """guidance_scale""": 7.5,
											    """output_type""": """numpy""",
											}
											return inputs







							def _a   (				self		):
											a__					   =		DiffusionPipeline.from_pretrained("""stabilityai/stable-diffusion-2-base"""		)
											pipe.to(a_		)
											pipe.set_progress_bar_config(disable=a_		)

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

											assert image.shape == (1, 512, 512, 3)
											a__					   =		np.array([0.49_493, 0.47_896, 0.40_798, 0.54_214, 0.53_212, 0.48_202, 0.47_656, 0.46_329, 0.48_506]		)
											assert np.abs(image_slice - expected_slice		).max() < 7E-3



'''simple docstring'''


import math
from collections.abc import Generator
def 					__magic_name__(       UpperCAmelCase__ :       int	):
						UpperCamelCase_     :	Generator					     =     (i for i in range(1							,				(max_n + 1)	))
						for i in (n for n in numbers if n > 1):
												for j in range(2							,				UpperCAmelCase__	):
																		if (i % j) == 0:
																								break
												else:
																		yield i
def 					__magic_name__(       UpperCAmelCase__ :       int	):
						UpperCamelCase_     :	Generator					     =     (i for i in range(1							,				(max_n + 1)	))
						for i in (n for n in numbers if n > 1):
												# only need to check for factors up to sqrt(i)
												UpperCamelCase_     :	List[Any]					     =     int(math.sqrt(UpperCAmelCase__	)	) + 1
												for j in range(2							,				UpperCAmelCase__	):
																		if (i % j) == 0:
																								break
												else:
																		yield i
def 					__magic_name__(       UpperCAmelCase__ :       int	):
						UpperCamelCase_     :	Generator					     =     (i for i in range(1							,				(max_n + 1)							,				2	))
						# It's useless to test even numbers as they will not be prime
						if max_n > 2:
												yield 2  # Because 2 will not be tested, it's necessary to yield it now
						for i in (n for n in numbers if n > 1):
												UpperCamelCase_     :	Optional[int]					     =     int(math.sqrt(UpperCAmelCase__	)	) + 1
												for j in range(3							,				UpperCAmelCase__							,				2	):
																		# As we removed the even numbers, we don't need them now
																		if (i % j) == 0:
																								break
												else:
																		yield i
def 					__magic_name__(       ):
						from timeit import timeit

						UpperCamelCase_     :	int					     =     """from __main__ import slow_primes, primes, fast_primes"""
						print(timeit("""slow_primes(1_000_000_000_000)"""							,				setup=UpperCAmelCase__							,				number=1000000	)	)
						print(timeit("""primes(1_000_000_000_000)"""							,				setup=UpperCAmelCase__							,				number=1000000	)	)
						print(timeit("""fast_primes(1_000_000_000_000)"""							,				setup=UpperCAmelCase__							,				number=1000000	)	)


if __name__ == "__main__":
	__SCREAMING_SNAKE_CASE						=      int(input("Calculate primes up to:\n>> ").strip())
	for ret in primes(number):
		print(ret)
	benchmark()




