





'''simple docstring'''






import gc
import random
import unittest

import numpy as np
import torch
from transformers import XLMRobertaTokenizerFast

from diffusers import DDIMScheduler, KandinskyPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel
from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP
from diffusers.utils import floats_tensor, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()



class  lowerCamelCase__				(						_lowerCAmelCase  ,							unittest.TestCase						):


	"""simple docstring"""





	__magic_name__							   =		KandinskyPipeline
	__magic_name__							   =		[
	    """prompt""",
	    """image_embeds""",
	    """negative_image_embeds""",
	]
	__magic_name__							   =		["""prompt""", """negative_prompt""", """image_embeds""", """negative_image_embeds"""]
	__magic_name__							   =		[
	    """generator""",
	    """height""",
	    """width""",
	    """latents""",
	    """guidance_scale""",
	    """negative_prompt""",
	    """num_inference_steps""",
	    """return_dict""",
	    """guidance_scale""",
	    """num_images_per_prompt""",
	    """output_type""",
	    """return_dict""",
	]
	__magic_name__							   =		False




	@property
	def 				_lowerCamelCase				(					self			)       ->				Optional[int]:
					return 3_2




	@property
	def 				_lowerCamelCase				(					self			)       ->				Union[str, Any]:
					return 3_2




	@property
	def 				_lowerCamelCase				(					self			)       ->				Tuple:
					return self.time_input_dim




	@property
	def 				_lowerCamelCase				(					self			)       ->				List[str]:
					return self.time_input_dim * 4




	@property
	def 				_lowerCamelCase				(					self			)       ->				List[str]:
					return 1_0_0




	@property
	def 				_lowerCamelCase				(					self			)       ->				Tuple:
					_A :				Dict				=  XLMRobertaTokenizerFast.from_pretrained('''YiYiXu/tiny-random-mclip-base'''			)
					return tokenizer




	@property
	def 				_lowerCamelCase				(					self			)       ->				List[Any]:
					torch.manual_seed(0			)
					_A :				Any				=  MCLIPConfig(
					    numDims=self.cross_attention_dim   ,     transformerDimensions=self.text_embedder_hidden_size   ,     hidden_size=self.text_embedder_hidden_size   ,     intermediate_size=3_7   ,     num_attention_heads=4   ,     num_hidden_layers=5   ,     vocab_size=1_0_0_5   ,     )

					_A :				Dict				=  MultilingualCLIP(__UpperCAmelCase			)
					_A :				List[Any]				=  text_encoder.eval()

					return text_encoder




	@property
	def 				_lowerCamelCase				(					self			)       ->				Any:
					torch.manual_seed(0			)

					_A :				Union[str, Any]				=  {
					    '''in_channels''': 4,
					    # Out channels is double in channels because predicts mean and variance
					    '''out_channels''': 8,
					    '''addition_embed_type''': '''text_image''',
					    '''down_block_types''': ('''ResnetDownsampleBlock2D''', '''SimpleCrossAttnDownBlock2D'''),
					    '''up_block_types''': ('''SimpleCrossAttnUpBlock2D''', '''ResnetUpsampleBlock2D'''),
					    '''mid_block_type''': '''UNetMidBlock2DSimpleCrossAttn''',
					    '''block_out_channels''': (self.block_out_channels_a, self.block_out_channels_a * 2),
					    '''layers_per_block''': 1,
					    '''encoder_hid_dim''': self.text_embedder_hidden_size,
					    '''encoder_hid_dim_type''': '''text_image_proj''',
					    '''cross_attention_dim''': self.cross_attention_dim,
					    '''attention_head_dim''': 4,
					    '''resnet_time_scale_shift''': '''scale_shift''',
					    '''class_embed_type''': None,
					}

					_A :				Optional[int]				=  UNetaDConditionModel(**__UpperCAmelCase			)
					return model




	@property
	def 				_lowerCamelCase				(					self			)       ->				Optional[Any]:
					return {
					    "block_out_channels": [3_2, 6_4],
					    "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"],
					    "in_channels": 3,
					    "latent_channels": 4,
					    "layers_per_block": 1,
					    "norm_num_groups": 8,
					    "norm_type": "spatial",
					    "num_vq_embeddings": 1_2,
					    "out_channels": 3,
					    "up_block_types": [
					        "AttnUpDecoderBlock2D",
					        "UpDecoderBlock2D",
					    ],
					    "vq_embed_dim": 4,
					}




	@property
	def 				_lowerCamelCase				(					self			)       ->				Dict:
					torch.manual_seed(0			)
					_A :				Union[str, Any]				=  VQModel(**self.dummy_movq_kwargs			)
					return model




	def 				_lowerCamelCase				(					self			)       ->				Tuple:
					_A :				List[Any]				=  self.dummy_text_encoder
					_A :				Union[str, Any]				=  self.dummy_tokenizer
					_A :				Dict				=  self.dummy_unet
					_A :				Optional[int]				=  self.dummy_movq

					_A :				List[Any]				=  DDIMScheduler(
					    num_train_timesteps=1_0_0_0   ,     beta_schedule='''linear'''   ,     beta_start=0.0_0_0_8_5   ,     beta_end=0.0_1_2   ,     clip_sample=__UpperCAmelCase   ,     set_alpha_to_one=__UpperCAmelCase   ,     steps_offset=1   ,     prediction_type='''epsilon'''   ,     thresholding=__UpperCAmelCase   ,     )

					_A :				Optional[Any]				=  {
					    '''text_encoder''': text_encoder,
					    '''tokenizer''': tokenizer,
					    '''unet''': unet,
					    '''scheduler''': scheduler,
					    '''movq''': movq,
					}
					return components




	def 				_lowerCamelCase				(					self   ,     UpperCAmelCase__   ,     UpperCAmelCase__=0			)       ->				Any:
					_A :				Dict				=  floats_tensor((1, self.cross_attention_dim)   ,     rng=random.Random(__UpperCAmelCase			)			).to(__UpperCAmelCase			)
					_A :				Dict				=  floats_tensor((1, self.cross_attention_dim)   ,     rng=random.Random(seed + 1			)			).to(__UpperCAmelCase			)
					if str(__UpperCAmelCase			).startswith('''mps'''			):
									_A :				Optional[Any]				=  torch.manual_seed(__UpperCAmelCase			)
					else:
									_A :				Optional[int]				=  torch.Generator(device=__UpperCAmelCase			).manual_seed(__UpperCAmelCase			)
					_A :				Any				=  {
					    '''prompt''': '''horse''',
					    '''image_embeds''': image_embeds,
					    '''negative_image_embeds''': negative_image_embeds,
					    '''generator''': generator,
					    '''height''': 6_4,
					    '''width''': 6_4,
					    '''guidance_scale''': 4.0,
					    '''num_inference_steps''': 2,
					    '''output_type''': '''np''',
					}
					return inputs




	def 				_lowerCamelCase				(					self			)       ->				Any:
					_A :				int				=  '''cpu'''

					_A :				Any				=  self.get_dummy_components()

					_A :				Union[str, Any]				=  self.pipeline_class(**__UpperCAmelCase			)
					_A :				str				=  pipe.to(__UpperCAmelCase			)

					pipe.set_progress_bar_config(disable=__UpperCAmelCase			)

					_A :				Tuple				=  pipe(**self.get_dummy_inputs(__UpperCAmelCase			)			)
					_A :				List[Any]				=  output.images

					_A :				str				=  pipe(
					    **self.get_dummy_inputs(__UpperCAmelCase			)   ,     return_dict=__UpperCAmelCase   ,     )[0]

					_A :				str				=  image[0, -3:, -3:, -1]
					_A :				Optional[Any]				=  image_from_tuple[0, -3:, -3:, -1]

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

					_A :				List[str]				=  np.array(
					    [0.3_2_8_6_6_3, 1.0, 0.2_3_2_1_6_8_7_3, 1.0, 0.9_2_7_1_7_5_6_4, 0.4_6_3_9_0_4_6, 0.9_6_8_9_4_7_7_7, 0.3_1_7_1_3_3_7_8, 0.6_2_9_3_9_5_3]			)

					assert (
					    np.abs(image_slice.flatten() - expected_slice			).max() < 1e-2
					), F""" expected_slice {expected_slice}, but got {image_slice.flatten()}"""
					assert (
					    np.abs(image_from_tuple_slice.flatten() - expected_slice			).max() < 1e-2
					), F""" expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}"""



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


	"""simple docstring"""





	def 				_lowerCamelCase				(					self			)       ->				Any:
					super().tearDown()
					gc.collect()
					torch.cuda.empty_cache()




	def 				_lowerCamelCase				(					self			)       ->				Optional[int]:
					_A :				int				=  load_numpy(
					    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
					    '''/kandinsky/kandinsky_text2img_cat_fp16.npy'''			)

					_A :				Dict				=  KandinskyPriorPipeline.from_pretrained(
					    '''kandinsky-community/kandinsky-2-1-prior'''   ,     torch_dtype=torch.floataa			)
					pipe_prior.to(__UpperCAmelCase			)

					_A :				str				=  KandinskyPipeline.from_pretrained('''kandinsky-community/kandinsky-2-1'''   ,     torch_dtype=torch.floataa			)
					_A :				Union[str, Any]				=  pipeline.to(__UpperCAmelCase			)
					pipeline.set_progress_bar_config(disable=__UpperCAmelCase			)

					_A :				str				=  '''red cat, 4k photo'''

					_A :				Dict				=  torch.Generator(device='''cuda'''			).manual_seed(0			)
					_A :				Union[str, Any]				=  pipe_prior(
					    __UpperCAmelCase   ,     generator=__UpperCAmelCase   ,     num_inference_steps=5   ,     negative_prompt=''''''   ,     ).to_tuple()

					_A :				Tuple				=  torch.Generator(device='''cuda'''			).manual_seed(0			)
					_A :				int				=  pipeline(
					    __UpperCAmelCase   ,     image_embeds=__UpperCAmelCase   ,     negative_image_embeds=__UpperCAmelCase   ,     generator=__UpperCAmelCase   ,     num_inference_steps=1_0_0   ,     output_type='''np'''   ,     )

					_A :				List[str]				=  output.images[0]

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

					assert_mean_pixel_difference(__UpperCAmelCase   ,     __UpperCAmelCase			)

"""simple docstring"""




import math
from collections.abc import Generator



def 				__a       (			_lowercase						):







					"""simple docstring"""





					lowerCamelCase__		:   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							, _lowercase						):
															if (i % j) == 0:
																				break
										else:
															yield i



def 				__a       (			_lowercase						):







					"""simple docstring"""





					lowerCamelCase__		:   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)
										lowerCamelCase__		:   Tuple  				=					int(math.sqrt(_lowercase						)						) + 1
										for j in range(2							, _lowercase						):
															if (i % j) == 0:
																				break
										else:
															yield i



def 				__a       (			_lowercase						):







					"""simple docstring"""





					lowerCamelCase__		:   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):
										lowerCamelCase__		:   Union[str, Any]  				=					int(math.sqrt(_lowercase						)						) + 1
										for j in range(3							, _lowercase							, 2						):
															# As we removed the even numbers, we don't need them now
															if (i % j) == 0:
																				break
										else:
															yield i



def 				__a       (			):







					"""simple docstring"""





					from timeit import timeit

					lowerCamelCase__		:   Any  				=					'''from __main__ import slow_primes, primes, fast_primes'''
					print(timeit('''slow_primes(1_000_000_000_000)'''							, setup=_lowercase							, number=1000000						)						)
					print(timeit('''primes(1_000_000_000_000)'''							, setup=_lowercase							, number=1000000						)						)
					print(timeit('''fast_primes(1_000_000_000_000)'''							, setup=_lowercase							, number=1000000						)						)


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






