





'''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  a_  (							SCREAMING_SNAKE_CASE__      ,		unittest.TestCase				):
     __A						=     KandinskyVaaInpaintPipeline
     __A						=     ["image_embeds", "negative_image_embeds", "image", "mask_image"]
     __A						=     [
         "image_embeds",
         "negative_image_embeds",
         "image",
         "mask_image",
     ]
     __A						=     [
         "generator",
         "height",
         "width",
         "latents",
         "guidance_scale",
         "num_inference_steps",
         "return_dict",
         "guidance_scale",
         "num_images_per_prompt",
         "output_type",
         "return_dict",
     ]
     __A						=     False





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





        """simple docstring"""




        return 32





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





        """simple docstring"""




        return 32





     @property
     def 				lowercase__ (					self						:   int		):





        """simple docstring"""




        return self.time_input_dim





     @property
     def 				lowercase__ (					self						:   Tuple		):





        """simple docstring"""




        return self.time_input_dim * 4





     @property
     def 				lowercase__ (					self						:   Tuple		):





        """simple docstring"""




        return 100





     @property
     def 				lowercase__ (					self						:   Any		):





        """simple docstring"""




        torch.manual_seed(0		)

        lowercase_     :int            =					{
            "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,
        }

        lowercase_     :Union[str, Any]            =					UNetaDConditionModel(**snake_case__		)
        return model





     @property
     def 				lowercase__ (					self						:   int		):





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





        """simple docstring"""




        torch.manual_seed(0		)
        lowercase_     :List[str]            =					VQModel(**self.dummy_movq_kwargs		)
        return model





     def 				lowercase__ (					self						:   List[str]		):





        """simple docstring"""




        lowercase_     :List[Any]            =					self.dummy_unet
        lowercase_     :Union[str, Any]            =					self.dummy_movq

        lowercase_     :str            =					DDIMScheduler(
            num_train_timesteps=1_000      , beta_schedule="linear"      , beta_start=0.0_00_85      , beta_end=0.0_12      , clip_sample=snake_case__      , set_alpha_to_one=snake_case__      , steps_offset=1      , prediction_type="epsilon"      , thresholding=snake_case__      , )

        lowercase_     :Optional[int]            =					{
            "unet": unet,
            "scheduler": scheduler,
            "movq": movq,
        }

        return components





     def 				lowercase__ (					self						:   str      , lowercase						:   Tuple      , lowercase						:   Optional[int]=0		):





        """simple docstring"""




        lowercase_     :int            =					floats_tensor((1, self.text_embedder_hidden_size)      , rng=random.Random(snake_case__		)		).to(snake_case__		)
        lowercase_     :Union[str, Any]            =					floats_tensor((1, self.text_embedder_hidden_size)      , rng=random.Random(seed + 1		)		).to(
            snake_case__		)
        # create init_image
        lowercase_     :int            =					floats_tensor((1, 3, 64, 64)      , rng=random.Random(snake_case__		)		).to(snake_case__		)
        lowercase_     :Tuple            =					image.cpu().permute(0      , 2      , 3      , 1		)[0]
        lowercase_     :str            =					Image.fromarray(np.uinta(snake_case__		)		).convert("RGB"		).resize((256, 256)		)
        # create mask
        lowercase_     :List[str]            =					np.ones((64, 64)      , dtype=np.floataa		)
        lowercase_     :Dict            =					0

        if str(snake_case__		).startswith("mps"		):
           lowercase_     :Any            =					torch.manual_seed(snake_case__		)
        else:
           lowercase_     :List[Any]            =					torch.Generator(device=snake_case__		).manual_seed(snake_case__		)
        lowercase_     :List[str]            =					{
            "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						:   str		):





        """simple docstring"""




        lowercase_     :Union[str, Any]            =					"cpu"

        lowercase_     :str            =					self.get_dummy_components()

        lowercase_     :Tuple            =					self.pipeline_class(**snake_case__		)
        lowercase_     :Dict            =					pipe.to(snake_case__		)

        pipe.set_progress_bar_config(disable=snake_case__		)

        lowercase_     :Optional[int]            =					pipe(**self.get_dummy_inputs(snake_case__		)		)
        lowercase_     :int            =					output.images

        lowercase_     :Union[str, Any]            =					pipe(
            **self.get_dummy_inputs(snake_case__		)      , return_dict=snake_case__      , )[0]

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

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

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

        lowercase_     :List[Any]            =					np.array(
            [0.50_77_59_03, 0.49_52_71_95, 0.48_82_45_43, 0.50_19_22_37, 0.48_64_49_06, 0.49_37_38_14, 0.4_78_05_98, 0.47_23_48_27, 0.48_32_78_48]		)

        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						:   List[Any]		):





        """simple docstring"""




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







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





     def 				lowercase__ (					self						:   List[Any]		):





        """simple docstring"""




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







     def 				lowercase__ (					self						:   Optional[int]		):





        """simple docstring"""




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

        lowercase_     :List[Any]            =					load_image(
            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main" "/kandinsky/cat.png"		)
        lowercase_     :int            =					np.ones((768, 768)      , dtype=np.floataa		)
        lowercase_     :Dict            =					0

        lowercase_     :Dict            =					"a hat"

        lowercase_     :Union[str, Any]            =					KandinskyVaaPriorPipeline.from_pretrained(
            "kandinsky-community/kandinsky-2-2-prior"      , torch_dtype=torch.floataa		)
        pipe_prior.to(snake_case__		)

        lowercase_     :str            =					KandinskyVaaInpaintPipeline.from_pretrained(
            "kandinsky-community/kandinsky-2-2-decoder-inpaint"      , torch_dtype=torch.floataa		)
        lowercase_     :Any            =					pipeline.to(snake_case__		)
        pipeline.set_progress_bar_config(disable=snake_case__		)

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

        lowercase_     :Tuple            =					pipeline(
            image=snake_case__      , mask_image=snake_case__      , image_embeds=snake_case__      , negative_image_embeds=snake_case__      , generator=snake_case__      , num_inference_steps=100      , height=768      , width=768      , output_type="np"      , )

        lowercase_     :Union[str, Any]            =					output.images[0]

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

        assert_mean_pixel_difference(snake_case__      , snake_case__		)








from __future__ import annotations

import math


def 					_a							(					lowerCAmelCase )->	bool:

		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


SCREAMING_SNAKE_CASE:     List[str]									= [num for num in range(3, 1_0_0_0_0_1, 2) if not is_prime(num)]


def 					_a							(					lowerCAmelCase )->	list[int]:
		if not isinstance(lowerCAmelCase    ,						lowerCAmelCase ):
				raise ValueError('n must be an integer' )
		if n <= 0:
				raise ValueError('n must be >= 0' )

		SCREAMING_SNAKE_CASE_					      =							[]
		for num in range(len(lowerCAmelCase ) ):
				SCREAMING_SNAKE_CASE_					      =							0
				while 2 * i * i <= odd_composites[num]:
						SCREAMING_SNAKE_CASE_					      =							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							(					)->	int:
		return compute_nums(1 )[0]


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