



"""simple docstring"""





import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image

from diffusers import (
    DDIMScheduler,
    KandinskyVaaInpaintPipeline,
    KandinskyVaaPriorPipeline,
    UNetaDConditionModel,
    VQModel,
)
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    lowercase__     (					SCREAMING_SNAKE_CASE       ,      unittest.TestCase   ):







       '''simple docstring'''


       UpperCamelCase		=  KandinskyVaaInpaintPipeline
       UpperCamelCase		=  ['''image_embeds''', '''negative_image_embeds''', '''image''', '''mask_image''']
       UpperCamelCase		=  [
           '''image_embeds''',
           '''negative_image_embeds''',
           '''image''',
           '''mask_image''',
       ]
       UpperCamelCase		=  [
           '''generator''',
           '''height''',
           '''width''',
           '''latents''',
           '''guidance_scale''',
           '''num_inference_steps''',
           '''return_dict''',
           '''guidance_scale''',
           '''num_images_per_prompt''',
           '''output_type''',
           '''return_dict''',
       ]
       UpperCamelCase		=  False



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


             '''simple docstring'''




             return 32



       @property
       def   lowercase__       (							self    :						Optional[Any]					)				->		Tuple:


             '''simple docstring'''




             return 32



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


             '''simple docstring'''




             return self.time_input_dim



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


             '''simple docstring'''




             return self.time_input_dim * 4



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


             '''simple docstring'''




             return 100



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


             '''simple docstring'''




             torch.manual_seed(0					)

             UpperCAmelCase_    				=							{
                 "in_channels": 9,
                 # Out channels is double in channels because predicts mean and variance
                 "out_channels": 8,
                 "addition_embed_type": "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": "image_proj",
                 "cross_attention_dim": self.cross_attention_dim,
                 "attention_head_dim": 4,
                 "resnet_time_scale_shift": "scale_shift",
                 "class_embed_type": None,
             }

             UpperCAmelCase_    				=							UNetaDConditionModel(**_UpperCAmelCase					)
             return model



       @property
       def   lowercase__       (							self    :						Optional[int]					)				->		str:


             '''simple docstring'''




             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    :						Any					)				->		Tuple:


             '''simple docstring'''




             torch.manual_seed(0					)
             UpperCAmelCase_    				=							VQModel(**self.dummy_movq_kwargs					)
             return model



       def   lowercase__       (							self    :						Tuple					)				->		int:


             '''simple docstring'''




             UpperCAmelCase_    				=							self.dummy_unet
             UpperCAmelCase_    				=							self.dummy_movq

             UpperCAmelCase_    				=							DDIMScheduler(
                 num_train_timesteps=1000	,       beta_schedule="linear"	,       beta_start=0.0_0085	,       beta_end=0.012	,       clip_sample=_UpperCAmelCase	,       set_alpha_to_one=_UpperCAmelCase	,       steps_offset=1	,       prediction_type="epsilon"	,       thresholding=_UpperCAmelCase	,       )

             UpperCAmelCase_    				=							{
                 "unet": unet,
                 "scheduler": scheduler,
                 "movq": movq,
             }

             return components



       def   lowercase__       (							self    :						Optional[int]	,       _UpperCAmelCase    :						Dict	,       _UpperCAmelCase    :						Tuple=0					)				->		Optional[int]:


             '''simple docstring'''




             UpperCAmelCase_    				=							floats_tensor((1, self.text_embedder_hidden_size)	,       rng=random.Random(_UpperCAmelCase					)					).to(_UpperCAmelCase					)
             UpperCAmelCase_    				=							floats_tensor((1, self.text_embedder_hidden_size)	,       rng=random.Random(seed + 1					)					).to(
                 _UpperCAmelCase					)
             # create init_image
             UpperCAmelCase_    				=							floats_tensor((1, 3, 64, 64)	,       rng=random.Random(_UpperCAmelCase					)					).to(_UpperCAmelCase					)
             UpperCAmelCase_    				=							image.cpu().permute(0	,       2	,       3	,       1					)[0]
             UpperCAmelCase_    				=							Image.fromarray(np.uinta(_UpperCAmelCase					)					).convert("RGB"					).resize((256, 256)					)
             # create mask
             UpperCAmelCase_    				=							np.ones((64, 64)	,       dtype=np.floataa					)
             UpperCAmelCase_    				=							0

             if str(_UpperCAmelCase					).startswith("mps"					):
                   UpperCAmelCase_    				=							torch.manual_seed(_UpperCAmelCase					)
             else:
                   UpperCAmelCase_    				=							torch.Generator(device=_UpperCAmelCase					).manual_seed(_UpperCAmelCase					)
             UpperCAmelCase_    				=							{
                 "image": init_image,
                 "mask_image": mask,
                 "image_embeds": image_embeds,
                 "negative_image_embeds": negative_image_embeds,
                 "generator": generator,
                 "height": 64,
                 "width": 64,
                 "num_inference_steps": 2,
                 "guidance_scale": 4.0,
                 "output_type": "np",
             }
             return inputs



       def   lowercase__       (							self    :						int					)				->		List[str]:


             '''simple docstring'''




             UpperCAmelCase_    				=							"cpu"

             UpperCAmelCase_    				=							self.get_dummy_components()

             UpperCAmelCase_    				=							self.pipeline_class(**_UpperCAmelCase					)
             UpperCAmelCase_    				=							pipe.to(_UpperCAmelCase					)

             pipe.set_progress_bar_config(disable=_UpperCAmelCase					)

             UpperCAmelCase_    				=							pipe(**self.get_dummy_inputs(_UpperCAmelCase					)					)
             UpperCAmelCase_    				=							output.images

             UpperCAmelCase_    				=							pipe(
                 **self.get_dummy_inputs(_UpperCAmelCase					)	,       return_dict=_UpperCAmelCase	,       )[0]

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

             print(F"""image.shape {image.shape}"""					)

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

             UpperCAmelCase_    				=							np.array(
                 [0.5077_5903, 0.4952_7195, 0.4882_4543, 0.5019_2237, 0.4864_4906, 0.4937_3814, 0.478_0598, 0.4723_4827, 0.4832_7848]					)

             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()}"""







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


             '''simple docstring'''




             super().test_inference_batch_single_identical(expected_max_diff=3e-3					)



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







       '''simple docstring'''


       def   lowercase__       (							self    :						Tuple					)				->		Dict:


             '''simple docstring'''




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







       def   lowercase__       (							self    :						Optional[int]					)				->		int:


             '''simple docstring'''




             UpperCAmelCase_    				=							load_numpy(
                 "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
                 "/kandinskyv22/kandinskyv22_inpaint_cat_with_hat_fp16.npy"					)

             UpperCAmelCase_    				=							load_image(
                 "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main" "/kandinsky/cat.png"					)
             UpperCAmelCase_    				=							np.ones((768, 768)	,       dtype=np.floataa					)
             UpperCAmelCase_    				=							0

             UpperCAmelCase_    				=							"a hat"

             UpperCAmelCase_    				=							KandinskyVaaPriorPipeline.from_pretrained(
                 "kandinsky-community/kandinsky-2-2-prior"	,       torch_dtype=torch.floataa					)
             pipe_prior.to(_UpperCAmelCase					)

             UpperCAmelCase_    				=							KandinskyVaaInpaintPipeline.from_pretrained(
                 "kandinsky-community/kandinsky-2-2-decoder-inpaint"	,       torch_dtype=torch.floataa					)
             UpperCAmelCase_    				=							pipeline.to(_UpperCAmelCase					)
             pipeline.set_progress_bar_config(disable=_UpperCAmelCase					)

             UpperCAmelCase_    				=							torch.Generator(device="cpu"					).manual_seed(0					)
             UpperCAmelCase_				,					UpperCAmelCase_    				=							pipe_prior(
                 _UpperCAmelCase	,       generator=_UpperCAmelCase	,       num_inference_steps=5	,       negative_prompt=""	,       ).to_tuple()

             UpperCAmelCase_    				=							pipeline(
                 image=_UpperCAmelCase	,       mask_image=_UpperCAmelCase	,       image_embeds=_UpperCAmelCase	,       negative_image_embeds=_UpperCAmelCase	,       generator=_UpperCAmelCase	,       num_inference_steps=100	,       height=768	,       width=768	,       output_type="np"	,       )

             UpperCAmelCase_    				=							output.images[0]

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

             assert_mean_pixel_difference(_UpperCAmelCase	,       _UpperCAmelCase					)









"""simple docstring"""





from __future__ import annotations

import math
def      a__			(   lowerCAmelCase__   ):

      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(lowerCAmelCase__   ) + 1   )			,    6   ):
            if number % i == 0 or number % (i + 2) == 0:
                  return False
      return True


lowerCamelCase      =		[num for num in range(3, 100_001, 2) if not is_prime(num)]
def      a__			(   lowerCAmelCase__   ):
      if not isinstance(lowerCAmelCase__			,    lowerCAmelCase__   ):
            raise ValueError("n must be an integer"   )
      if n <= 0:
            raise ValueError("n must be >= 0"   )

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

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


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




