import gc
import random
import unittest

import numpy as np
import torch
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModelWithProjection,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import (
    DiffusionPipeline,
    UnCLIPImageVariationPipeline,
    UnCLIPScheduler,
    UNetaDConditionModel,
    UNetaDModel,
)
from diffusers.pipelines.unclip.text_proj import UnCLIPTextProjModel
from diffusers.utils import floats_tensor, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, load_image, require_torch_gpu, skip_mps

from ..pipeline_params import IMAGE_VARIATION_BATCH_PARAMS, IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()


class 						lowercase    (     a				,       unittest.TestCase     ):
							lowercase__						:       Optional[Any]								=							UnCLIPImageVariationPipeline
							lowercase__						:       Dict								=							IMAGE_VARIATION_PARAMS - {"""height""", """width""", """guidance_scale"""}
							lowercase__						:       int								=							IMAGE_VARIATION_BATCH_PARAMS

							lowercase__						:       Tuple								=							[
							    """generator""",
							    """return_dict""",
							    """decoder_num_inference_steps""",
							    """super_res_num_inference_steps""",
							]
							lowercase__						:       int								=							False




							@property
							def 	__snake_case(						self   :					Tuple      )					->				List[str]:



												'''simple docstring'''

												return 32




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



												'''simple docstring'''

												return 32




							@property
							def 	__snake_case(						self   :					Optional[Any]      )					->				List[Any]:



												'''simple docstring'''

												return self.time_input_dim




							@property
							def 	__snake_case(						self   :					Optional[int]      )					->				Any:



												'''simple docstring'''

												return self.time_input_dim * 4




							@property
							def 	__snake_case(						self   :					List[Any]      )					->				str:



												'''simple docstring'''

												return 100




							@property
							def 	__snake_case(						self   :					Any      )					->				Union[str, Any]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"      )
												return tokenizer




							@property
							def 	__snake_case(						self   :					str      )					->				str:



												'''simple docstring'''

												torch.manual_seed(0      )
												SCREAMING_SNAKE_CASE    			=       CLIPTextConfig(
												    bos_token_id=0	,							eos_token_id=2	,							hidden_size=self.text_embedder_hidden_size	,							projection_dim=self.text_embedder_hidden_size	,							intermediate_size=37	,							layer_norm_eps=1e-05	,							num_attention_heads=4	,							num_hidden_layers=5	,							pad_token_id=1	,							vocab_size=1_000	,							)
												return CLIPTextModelWithProjection(_UpperCamelCase      )




							@property
							def 	__snake_case(						self   :					Dict      )					->				Tuple:



												'''simple docstring'''

												torch.manual_seed(0      )
												SCREAMING_SNAKE_CASE    			=       CLIPVisionConfig(
												    hidden_size=self.text_embedder_hidden_size	,							projection_dim=self.text_embedder_hidden_size	,							num_hidden_layers=5	,							num_attention_heads=4	,							image_size=32	,							intermediate_size=37	,							patch_size=1	,							)
												return CLIPVisionModelWithProjection(_UpperCamelCase      )




							@property
							def 	__snake_case(						self   :					str      )					->				int:



												'''simple docstring'''

												torch.manual_seed(0      )

												SCREAMING_SNAKE_CASE    			=       {
												    "clip_embeddings_dim": self.text_embedder_hidden_size,
												    "time_embed_dim": self.time_embed_dim,
												    "cross_attention_dim": self.cross_attention_dim,
												}

												SCREAMING_SNAKE_CASE    			=       UnCLIPTextProjModel(**_UpperCamelCase      )
												return model




							@property
							def 	__snake_case(						self   :					List[Any]      )					->				int:



												'''simple docstring'''

												torch.manual_seed(0      )

												SCREAMING_SNAKE_CASE    			=       {
												    "sample_size": 32,
												    # RGB in channels
												    "in_channels": 3,
												    # Out channels is double in channels because predicts mean and variance
												    "out_channels": 6,
												    "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,
												    "cross_attention_dim": self.cross_attention_dim,
												    "attention_head_dim": 4,
												    "resnet_time_scale_shift": "scale_shift",
												    "class_embed_type": "identity",
												}

												SCREAMING_SNAKE_CASE    			=       UNetaDConditionModel(**_UpperCamelCase      )
												return model




							@property
							def 	__snake_case(						self   :					List[Any]      )					->				Tuple:



												'''simple docstring'''

												return {
												    "sample_size": 64,
												    "layers_per_block": 1,
												    "down_block_types": ("ResnetDownsampleBlock2D", "ResnetDownsampleBlock2D"),
												    "up_block_types": ("ResnetUpsampleBlock2D", "ResnetUpsampleBlock2D"),
												    "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
												    "in_channels": 6,
												    "out_channels": 3,
												}




							@property
							def 	__snake_case(						self   :					str      )					->				Any:



												'''simple docstring'''

												torch.manual_seed(0      )

												SCREAMING_SNAKE_CASE    			=       UNetaDModel(**self.dummy_super_res_kwargs      )
												return model




							@property
							def 	__snake_case(						self   :					Optional[Any]      )					->				Dict:



												'''simple docstring'''

												torch.manual_seed(1      )

												SCREAMING_SNAKE_CASE    			=       UNetaDModel(**self.dummy_super_res_kwargs      )
												return model




							def 	__snake_case(						self   :					Union[str, Any]      )					->				int:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       self.dummy_decoder
												SCREAMING_SNAKE_CASE    			=       self.dummy_text_proj
												SCREAMING_SNAKE_CASE    			=       self.dummy_text_encoder
												SCREAMING_SNAKE_CASE    			=       self.dummy_tokenizer
												SCREAMING_SNAKE_CASE    			=       self.dummy_super_res_first
												SCREAMING_SNAKE_CASE    			=       self.dummy_super_res_last

												SCREAMING_SNAKE_CASE    			=       UnCLIPScheduler(
												    variance_type="learned_range"	,							prediction_type="epsilon"	,							num_train_timesteps=1_000	,							)

												SCREAMING_SNAKE_CASE    			=       UnCLIPScheduler(
												    variance_type="fixed_small_log"	,							prediction_type="epsilon"	,							num_train_timesteps=1_000	,							)

												SCREAMING_SNAKE_CASE    			=       CLIPImageProcessor(crop_size=32	,							size=32      )

												SCREAMING_SNAKE_CASE    			=       self.dummy_image_encoder

												return {
												    "decoder": decoder,
												    "text_encoder": text_encoder,
												    "tokenizer": tokenizer,
												    "text_proj": text_proj,
												    "feature_extractor": feature_extractor,
												    "image_encoder": image_encoder,
												    "super_res_first": super_res_first,
												    "super_res_last": super_res_last,
												    "decoder_scheduler": decoder_scheduler,
												    "super_res_scheduler": super_res_scheduler,
												}




							def 	__snake_case(						self   :					Optional[Any]	,							_UpperCamelCase   :					Optional[int]	,							_UpperCamelCase   :					Optional[int]=0	,							_UpperCamelCase   :					int=True      )					->				int:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       floats_tensor((1, 3, 32, 32)	,							rng=random.Random(_UpperCamelCase      )      ).to(_UpperCamelCase      )
												if str(_UpperCamelCase      ).startswith("mps"      ):
																	SCREAMING_SNAKE_CASE    			=       torch.manual_seed(_UpperCamelCase      )
												else:
																	SCREAMING_SNAKE_CASE    			=       torch.Generator(device=_UpperCamelCase      ).manual_seed(_UpperCamelCase      )

												if pil_image:
																	SCREAMING_SNAKE_CASE    			=       input_image * 0.5 + 0.5
																	SCREAMING_SNAKE_CASE    			=       input_image.clamp(0	,							1      )
																	SCREAMING_SNAKE_CASE    			=       input_image.cpu().permute(0	,							2	,							3	,							1      ).float().numpy()
																	SCREAMING_SNAKE_CASE    			=       DiffusionPipeline.numpy_to_pil(_UpperCamelCase      )[0]

												return {
												    "image": input_image,
												    "generator": generator,
												    "decoder_num_inference_steps": 2,
												    "super_res_num_inference_steps": 2,
												    "output_type": "np",
												}




							def 	__snake_case(						self   :					str      )					->				Tuple:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       "cpu"

												SCREAMING_SNAKE_CASE    			=       self.get_dummy_components()

												SCREAMING_SNAKE_CASE    			=       self.pipeline_class(**_UpperCamelCase      )
												SCREAMING_SNAKE_CASE    			=       pipe.to(_UpperCamelCase      )

												pipe.set_progress_bar_config(disable=_UpperCamelCase      )

												SCREAMING_SNAKE_CASE    			=       self.get_dummy_inputs(_UpperCamelCase	,							pil_image=_UpperCamelCase      )

												SCREAMING_SNAKE_CASE    			=       pipe(**_UpperCamelCase      )
												SCREAMING_SNAKE_CASE    			=       output.images

												SCREAMING_SNAKE_CASE    			=       self.get_dummy_inputs(_UpperCamelCase	,							pil_image=_UpperCamelCase      )

												SCREAMING_SNAKE_CASE    			=       pipe(
												    **_UpperCamelCase	,							return_dict=_UpperCamelCase	,							)[0]

												SCREAMING_SNAKE_CASE    			=       image[0, -3:, -3:, -1]
												SCREAMING_SNAKE_CASE    			=       image_from_tuple[0, -3:, -3:, -1]

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

												SCREAMING_SNAKE_CASE    			=       np.array(
												    [
												        0.9_9_9_7,
												        0.0_0_0_2,
												        0.9_9_9_7,
												        0.9_9_9_7,
												        0.9_9_6_9,
												        0.0_0_2_3,
												        0.9_9_9_7,
												        0.9_9_6_9,
												        0.9_9_7_0,
												    ]      )

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




							def 	__snake_case(						self   :					Optional[int]      )					->				Tuple:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       "cpu"

												SCREAMING_SNAKE_CASE    			=       self.get_dummy_components()

												SCREAMING_SNAKE_CASE    			=       self.pipeline_class(**_UpperCamelCase      )
												SCREAMING_SNAKE_CASE    			=       pipe.to(_UpperCamelCase      )

												pipe.set_progress_bar_config(disable=_UpperCamelCase      )

												SCREAMING_SNAKE_CASE    			=       self.get_dummy_inputs(_UpperCamelCase	,							pil_image=_UpperCamelCase      )

												SCREAMING_SNAKE_CASE    			=       pipe(**_UpperCamelCase      )
												SCREAMING_SNAKE_CASE    			=       output.images

												SCREAMING_SNAKE_CASE    			=       self.get_dummy_inputs(_UpperCamelCase	,							pil_image=_UpperCamelCase      )

												SCREAMING_SNAKE_CASE    			=       pipe(
												    **_UpperCamelCase	,							return_dict=_UpperCamelCase	,							)[0]

												SCREAMING_SNAKE_CASE    			=       image[0, -3:, -3:, -1]
												SCREAMING_SNAKE_CASE    			=       image_from_tuple[0, -3:, -3:, -1]

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

												SCREAMING_SNAKE_CASE    			=       np.array([0.9_9_9_7, 0.0_0_0_3, 0.9_9_9_7, 0.9_9_9_7, 0.9_9_7_0, 0.0_0_2_4, 0.9_9_9_7, 0.9_9_7_1, 0.9_9_7_1]      )

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




							def 	__snake_case(						self   :					Any      )					->				str:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       "cpu"

												SCREAMING_SNAKE_CASE    			=       self.get_dummy_components()

												SCREAMING_SNAKE_CASE    			=       self.pipeline_class(**_UpperCamelCase      )
												SCREAMING_SNAKE_CASE    			=       pipe.to(_UpperCamelCase      )

												pipe.set_progress_bar_config(disable=_UpperCamelCase      )

												SCREAMING_SNAKE_CASE    			=       self.get_dummy_inputs(_UpperCamelCase	,							pil_image=_UpperCamelCase      )
												SCREAMING_SNAKE_CASE    			=       [
												    pipeline_inputs["image"],
												    pipeline_inputs["image"],
												]

												SCREAMING_SNAKE_CASE    			=       pipe(**_UpperCamelCase      )
												SCREAMING_SNAKE_CASE    			=       output.images

												SCREAMING_SNAKE_CASE    			=       self.get_dummy_inputs(_UpperCamelCase	,							pil_image=_UpperCamelCase      )
												SCREAMING_SNAKE_CASE    			=       [
												    tuple_pipeline_inputs["image"],
												    tuple_pipeline_inputs["image"],
												]

												SCREAMING_SNAKE_CASE    			=       pipe(
												    **_UpperCamelCase	,							return_dict=_UpperCamelCase	,							)[0]

												SCREAMING_SNAKE_CASE    			=       image[0, -3:, -3:, -1]
												SCREAMING_SNAKE_CASE    			=       image_from_tuple[0, -3:, -3:, -1]

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

												SCREAMING_SNAKE_CASE    			=       np.array(
												    [
												        0.9_9_9_7,
												        0.9_9_8_9,
												        0.0_0_0_8,
												        0.0_0_2_1,
												        0.9_9_6_0,
												        0.0_0_1_8,
												        0.0_0_1_4,
												        0.0_0_0_2,
												        0.9_9_3_3,
												    ]      )

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




							def 	__snake_case(						self   :					List[str]      )					->				Any:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       torch.device("cpu"      )


												class 						lowercase    :
																			lowercase__						:       Optional[Any]								=							1



												SCREAMING_SNAKE_CASE    			=       self.get_dummy_components()

												SCREAMING_SNAKE_CASE    			=       self.pipeline_class(**_UpperCamelCase      )
												SCREAMING_SNAKE_CASE    			=       pipe.to(_UpperCamelCase      )

												pipe.set_progress_bar_config(disable=_UpperCamelCase      )

												SCREAMING_SNAKE_CASE    			=       torch.Generator(device=_UpperCamelCase      ).manual_seed(0      )
												SCREAMING_SNAKE_CASE    			=       pipe.decoder.dtype
												SCREAMING_SNAKE_CASE    			=       1

												SCREAMING_SNAKE_CASE    			=       (
												    batch_size,
												    pipe.decoder.config.in_channels,
												    pipe.decoder.config.sample_size,
												    pipe.decoder.config.sample_size,
												)
												SCREAMING_SNAKE_CASE    			=       pipe.prepare_latents(
												    _UpperCamelCase	,							dtype=_UpperCamelCase	,							device=_UpperCamelCase	,							generator=_UpperCamelCase	,							latents=_UpperCamelCase	,							scheduler=DummyScheduler()      )

												SCREAMING_SNAKE_CASE    			=       (
												    batch_size,
												    pipe.super_res_first.config.in_channels // 2,
												    pipe.super_res_first.config.sample_size,
												    pipe.super_res_first.config.sample_size,
												)
												SCREAMING_SNAKE_CASE    			=       pipe.prepare_latents(
												    _UpperCamelCase	,							dtype=_UpperCamelCase	,							device=_UpperCamelCase	,							generator=_UpperCamelCase	,							latents=_UpperCamelCase	,							scheduler=DummyScheduler()      )

												SCREAMING_SNAKE_CASE    			=       self.get_dummy_inputs(_UpperCamelCase	,							pil_image=_UpperCamelCase      )

												SCREAMING_SNAKE_CASE    			=       pipe(
												    **_UpperCamelCase	,							decoder_latents=_UpperCamelCase	,							super_res_latents=_UpperCamelCase      ).images

												SCREAMING_SNAKE_CASE    			=       self.get_dummy_inputs(_UpperCamelCase	,							pil_image=_UpperCamelCase      )
												# Don't pass image, instead pass embedding
												SCREAMING_SNAKE_CASE    			=       pipeline_inputs.pop("image"      )
												SCREAMING_SNAKE_CASE    			=       pipe.image_encoder(_UpperCamelCase      ).image_embeds

												SCREAMING_SNAKE_CASE    			=       pipe(
												    **_UpperCamelCase	,							decoder_latents=_UpperCamelCase	,							super_res_latents=_UpperCamelCase	,							image_embeddings=_UpperCamelCase	,							).images

												# make sure passing text embeddings manually is identical
												assert np.abs(img_out_a - img_out_a      ).max() < 1e-4




							@skip_mps
							def 	__snake_case(						self   :					Union[str, Any]      )					->				List[Any]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       torch_device == "cpu"

												# Check is relaxed because there is not a torch 2.0 sliced attention added kv processor
												SCREAMING_SNAKE_CASE    			=       1e-2

												self._test_attention_slicing_forward_pass(
												    test_max_difference=_UpperCamelCase	,							expected_max_diff=_UpperCamelCase      )




							@skip_mps
							def 	__snake_case(						self   :					List[str]      )					->				Tuple:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       torch_device == "cpu"
												SCREAMING_SNAKE_CASE    			=       True
												SCREAMING_SNAKE_CASE    			=       [
												    "decoder_num_inference_steps",
												    "super_res_num_inference_steps",
												]

												self._test_inference_batch_single_identical(
												    test_max_difference=_UpperCamelCase	,							relax_max_difference=_UpperCamelCase	,							additional_params_copy_to_batched_inputs=_UpperCamelCase	,							)




							def 	__snake_case(						self   :					Optional[int]      )					->				Any:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       [
												    "decoder_num_inference_steps",
												    "super_res_num_inference_steps",
												]

												if torch_device == "mps":
																	# TODO: MPS errors with larger batch sizes
																	SCREAMING_SNAKE_CASE    			=       [2, 3]
																	self._test_inference_batch_consistent(
																	    batch_sizes=_UpperCamelCase	,							additional_params_copy_to_batched_inputs=_UpperCamelCase	,							)
												else:
																	self._test_inference_batch_consistent(
																	    additional_params_copy_to_batched_inputs=_UpperCamelCase      )




							@skip_mps
							def 	__snake_case(						self   :					str      )					->				List[str]:



												'''simple docstring'''

												return super().test_dict_tuple_outputs_equivalent()




							@skip_mps
							def 	__snake_case(						self   :					Tuple      )					->				str:



												'''simple docstring'''

												return super().test_save_load_local()





							@skip_mps
							def 	__snake_case(						self   :					List[str]      )					->				List[Any]:



												'''simple docstring'''

												return super().test_save_load_optional_components()



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




							def 	__snake_case(						self   :					List[Any]      )					->				int:



												'''simple docstring'''

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





							def 	__snake_case(						self   :					Tuple      )					->				Optional[Any]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       load_image(
												    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/unclip/cat.png"      )
												SCREAMING_SNAKE_CASE    			=       load_numpy(
												    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
												    "/unclip/karlo_v1_alpha_cat_variation_fp16.npy"      )

												SCREAMING_SNAKE_CASE    			=       UnCLIPImageVariationPipeline.from_pretrained(
												    "kakaobrain/karlo-v1-alpha-image-variations"	,							torch_dtype=torch.floataa      )
												SCREAMING_SNAKE_CASE    			=       pipeline.to(_UpperCamelCase      )
												pipeline.set_progress_bar_config(disable=_UpperCamelCase      )

												SCREAMING_SNAKE_CASE    			=       torch.Generator(device="cpu"      ).manual_seed(0      )
												SCREAMING_SNAKE_CASE    			=       pipeline(
												    _UpperCamelCase	,							generator=_UpperCamelCase	,							output_type="np"	,							)

												SCREAMING_SNAKE_CASE    			=       output.images[0]

												assert image.shape == (256, 256, 3)

												assert_mean_pixel_difference(_UpperCamelCase	,							_UpperCamelCase	,							15      )





from __future__ import annotations

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


_lowerCamelCase					:   Tuple							=		[num for num in range(3, 10_00_01, 2) if not is_prime(num)]





def 	__lowerCamelCase							(UpperCAmelCase__     :							int  ):
					if not isinstance(UpperCAmelCase__      , UpperCAmelCase__  ):
										raise ValueError("n must be an integer"  )
					if n <= 0:
										raise ValueError("n must be >= 0"  )

					SCREAMING_SNAKE_CASE    			=       []
					for num in range(len(UpperCAmelCase__  )  ):
										SCREAMING_SNAKE_CASE    			=       0
										while 2 * i * i <= odd_composites[num]:
															SCREAMING_SNAKE_CASE    			=       odd_composites[num] - 2 * i * i
															if is_prime(UpperCAmelCase__  ):
																				break
															i += 1
										else:
															list_nums.append(odd_composites[num]  )
															if len(UpperCAmelCase__  ) == n:
																				return list_nums

					return []





def 	__lowerCamelCase							():
					return compute_nums(1  )[0]


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




