"""simple docstring"""







import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import XLMRobertaTokenizerFast

from diffusers import DDIMScheduler, KandinskyImgaImgPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel
from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP
from diffusers.utils import floats_tensor, load_image, 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 	UpperCamelCase    (					lowercase   ,			unittest.TestCase		):
				UpperCAmelCase       :   Union[str, Any]					=	KandinskyImgaImgPipeline
				UpperCAmelCase       :   Tuple					=	["""prompt""", """image_embeds""", """negative_image_embeds""", """image"""]
				UpperCAmelCase       :   Any					=	[
				    """prompt""",
				    """negative_prompt""",
				    """image_embeds""",
				    """negative_image_embeds""",
				    """image""",
				]
				UpperCAmelCase       :   Optional[Any]					=	[
				    """generator""",
				    """height""",
				    """width""",
				    """strength""",
				    """guidance_scale""",
				    """negative_prompt""",
				    """num_inference_steps""",
				    """return_dict""",
				    """guidance_scale""",
				    """num_images_per_prompt""",
				    """output_type""",
				    """return_dict""",
				]
				UpperCAmelCase       :   Any					=	False



				@property
				def       _lowercase  (self       :   Optional[Any])					->			str:
					return 32



				@property
				def       _lowercase  (self       :   Union[str, Any])					->			Optional[Any]:
					return 32



				@property
				def       _lowercase  (self       :   Union[str, Any])					->			Union[str, Any]:
					return self.time_input_dim



				@property
				def       _lowercase  (self       :   Union[str, Any])					->			int:
					return self.time_input_dim * 4



				@property
				def       _lowercase  (self       :   Optional[Any])					->			str:
					return 1_00



				@property
				def       _lowercase  (self       :   Optional[int])					->			Tuple:
					__snake_case    :							Any   	=				XLMRobertaTokenizerFast.from_pretrained('YiYiXu/tiny-random-mclip-base')
					return tokenizer



				@property
				def       _lowercase  (self       :   List[str])					->			Tuple:
					torch.manual_seed(0)
					__snake_case    :							Dict   	=				MCLIPConfig(
					    numDims=self.cross_attention_dim			,						transformerDimensions=self.text_embedder_hidden_size			,						hidden_size=self.text_embedder_hidden_size			,						intermediate_size=37			,						num_attention_heads=4			,						num_hidden_layers=5			,						vocab_size=10_05			,						)

					__snake_case    :							Any   	=				MultilingualCLIP(_A)
					__snake_case    :							int   	=				text_encoder.eval()

					return text_encoder



				@property
				def       _lowercase  (self       :   Tuple)					->			str:
					torch.manual_seed(0)

					__snake_case    :							List[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,
					}

					__snake_case    :							Any   	=				UNetaDConditionModel(**_A)
					return model



				@property
				def       _lowercase  (self       :   Tuple)					->			Tuple:
					return {
					    "block_out_channels": [32, 64],
					    "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": 12,
					    "out_channels": 3,
					    "up_block_types": [
					        "AttnUpDecoderBlock2D",
					        "UpDecoderBlock2D",
					    ],
					    "vq_embed_dim": 4,
					}



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



				def       _lowercase  (self       :   Optional[int])					->			List[str]:
					__snake_case    :							Optional[int]   	=				self.dummy_text_encoder
					__snake_case    :							Any   	=				self.dummy_tokenizer
					__snake_case    :							str   	=				self.dummy_unet
					__snake_case    :							Tuple   	=				self.dummy_movq

					__snake_case    :							int   	=				{
					    'num_train_timesteps': 10_00,
					    'beta_schedule': 'linear',
					    'beta_start': 0.00_085,
					    'beta_end': 0.012,
					    'clip_sample': False,
					    'set_alpha_to_one': False,
					    'steps_offset': 0,
					    'prediction_type': 'epsilon',
					    'thresholding': False,
					}

					__snake_case    :							Optional[Any]   	=				DDIMScheduler(**_A)

					__snake_case    :							Tuple   	=				{
					    'text_encoder': text_encoder,
					    'tokenizer': tokenizer,
					    'unet': unet,
					    'scheduler': scheduler,
					    'movq': movq,
					}

					return components



				def       _lowercase  (self       :   Union[str, Any]			,						_A       :   List[Any]			,						_A       :   Optional[Any]=0)					->			Tuple:
					__snake_case    :							int   	=				floats_tensor((1, self.cross_attention_dim)			,						rng=random.Random(_A)).to(_A)
					__snake_case    :							Union[str, Any]   	=				floats_tensor((1, self.cross_attention_dim)			,						rng=random.Random(seed + 1)).to(_A)
					# create init_image
					__snake_case    :							Dict   	=				floats_tensor((1, 3, 64, 64)			,						rng=random.Random(_A)).to(_A)
					__snake_case    :							Optional[Any]   	=				image.cpu().permute(0			,						2			,						3			,						1)[0]
					__snake_case    :							Tuple   	=				Image.fromarray(np.uinta(_A)).convert('RGB').resize((2_56, 2_56))

					if str(_A).startswith('mps'):
						__snake_case    :							List[str]   	=				torch.manual_seed(_A)
					else:
						__snake_case    :							Any   	=				torch.Generator(device=_A).manual_seed(_A)
					__snake_case    :							Any   	=				{
					    'prompt': 'horse',
					    'image': init_image,
					    'image_embeds': image_embeds,
					    'negative_image_embeds': negative_image_embeds,
					    'generator': generator,
					    'height': 64,
					    'width': 64,
					    'num_inference_steps': 10,
					    'guidance_scale': 7.0,
					    'strength': 0.2,
					    'output_type': 'np',
					}
					return inputs






				def       _lowercase  (self       :   str)					->			Tuple:
					__snake_case    :							List[str]   	=				'cpu'

					__snake_case    :							Optional[int]   	=				self.get_dummy_components()

					__snake_case    :							Any   	=				self.pipeline_class(**_A)
					__snake_case    :							int   	=				pipe.to(_A)

					pipe.set_progress_bar_config(disable=_A)

					__snake_case    :							Any   	=				pipe(**self.get_dummy_inputs(_A))
					__snake_case    :							Optional[int]   	=				output.images

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

					__snake_case    :							int   	=				image[0, -3:, -3:, -1]
					__snake_case    :							Optional[Any]   	=				image_from_tuple[0, -3:, -3:, -1]

					assert image.shape == (1, 64, 64, 3)

					__snake_case    :							Tuple   	=				np.array(
					    [0.61_474_943, 0.6_073_539, 0.43_308_544, 0.5_928_269, 0.47_493_595, 0.46_755_973, 0.4_613_838, 0.45_368_797, 0.50_119_233])
					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 	UpperCamelCase    (					unittest.TestCase		):



				def       _lowercase  (self       :   List[str])					->			List[Any]:
					# clean up the VRAM after each test
					super().tearDown()
					gc.collect()
					torch.cuda.empty_cache()






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

					__snake_case    :							List[str]   	=				load_image(
					    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/kandinsky/cat.png')
					__snake_case    :							List[Any]   	=				'A red cartoon frog, 4k'

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

					__snake_case    :							List[str]   	=				KandinskyImgaImgPipeline.from_pretrained(
					    'kandinsky-community/kandinsky-2-1'			,						torch_dtype=torch.floataa)
					__snake_case    :							List[Any]   	=				pipeline.to(_A)

					pipeline.set_progress_bar_config(disable=_A)

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

					__snake_case    :							List[str]   	=				pipeline(
					    _A			,						image=_A			,						image_embeds=_A			,						negative_image_embeds=_A			,						generator=_A			,						num_inference_steps=1_00			,						height=7_68			,						width=7_68			,						strength=0.2			,						output_type='np'			,						)

					__snake_case    :							Optional[Any]   	=				output.images[0]

					assert image.shape == (7_68, 7_68, 3)

					assert_mean_pixel_difference(_A			,						_A)






"""simple docstring"""







from __future__ import annotations
def 						__UpperCAmelCase       (					UpperCAmelCase_					:       int						)							->    list[int]:

	'''simple docstring'''





	__snake_case    :							Union[str, Any]   	=				[True] * limit
	__snake_case    :							Tuple   	=				False
	__snake_case    :							Union[str, Any]   	=				False
	__snake_case    :							List[str]   	=				True

	for i in range(3    ,							int(limit**0.5 + 1						)    ,							2						):
		__snake_case    :							List[str]   	=				i * 2
		while index < limit:
			__snake_case    :							List[str]   	=				False
			__snake_case    :							Union[str, Any]   	=				index + i

	__snake_case    :							str   	=				[2]

	for i in range(3    ,							UpperCAmelCase_    ,							2						):
		if is_prime[i]:
			primes.append(UpperCAmelCase_						)

	return primes
def 						__UpperCAmelCase       (					UpperCAmelCase_					:       int = 1_00_00_00						)							->    int:

	'''simple docstring'''





	__snake_case    :							Tuple   	=				prime_sieve(UpperCAmelCase_						)
	__snake_case    :							int   	=				0
	__snake_case    :							str   	=				0

	for i in range(len(UpperCAmelCase_						)						):
		for j in range(i + length    ,							len(UpperCAmelCase_						)						):
			__snake_case    :							Union[str, Any]   	=				sum(primes[i:j]						)
			if sol >= ceiling:
				break

			if sol in primes:
				__snake_case    :							List[Any]   	=				j - i
				__snake_case    :							Optional[Any]   	=				sol

	return largest


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





