





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





      @property
      def     _snake_case			(       self )		->     List[str]:
            return 32





      @property
      def     _snake_case			(       self )		->     Optional[int]:
            return 32





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





      @property
      def     _snake_case			(       self )		->     int:
            return self.time_input_dim * 4





      @property
      def     _snake_case			(       self )		->     Optional[int]:
            return 100





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

            lowerCAmelCase  						=       {
                """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,
            }

            lowerCAmelCase  						=       UNetaDConditionModel(**lowercase )
            return model





      @property
      def     _snake_case			(       self )		->     List[Any]:
            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     _snake_case			(       self )		->     Optional[Any]:
            torch.manual_seed(0 )
            lowerCAmelCase  						=       VQModel(**self.dummy_movq_kwargs )
            return model





      def     _snake_case			(       self )		->     Any:
            lowerCAmelCase  						=       self.dummy_unet
            lowerCAmelCase  						=       self.dummy_movq

            lowerCAmelCase  						=       DDIMScheduler(
                num_train_timesteps=1_000      ,						beta_schedule="""linear"""      ,						beta_start=0.00_085      ,						beta_end=0.012      ,						clip_sample=lowercase      ,						set_alpha_to_one=lowercase      ,						steps_offset=1      ,						prediction_type="""epsilon"""      ,						thresholding=lowercase      ,						)

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

            return components





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

            if str(lowercase ).startswith("""mps""" ):
                  lowerCAmelCase  						=       torch.manual_seed(lowercase )
            else:
                  lowerCAmelCase  						=       torch.Generator(device=lowercase ).manual_seed(lowercase )
            lowerCAmelCase  						=       {
                """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     _snake_case			(       self )		->     Any:
            lowerCAmelCase  						=       """cpu"""

            lowerCAmelCase  						=       self.get_dummy_components()

            lowerCAmelCase  						=       self.pipeline_class(**lowercase )
            lowerCAmelCase  						=       pipe.to(lowercase )

            pipe.set_progress_bar_config(disable=lowercase )

            lowerCAmelCase  						=       pipe(**self.get_dummy_inputs(lowercase ) )
            lowerCAmelCase  						=       output.images

            lowerCAmelCase  						=       pipe(
                **self.get_dummy_inputs(lowercase )      ,						return_dict=lowercase      ,						)[0]

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

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

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

            lowerCAmelCase  						=       np.array(
                [0.50_775_903, 0.49_527_195, 0.48_824_543, 0.50_192_237, 0.48_644_906, 0.49_373_814, 0.4_780_598, 0.47_234_827, 0.48_327_848] )

            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     _snake_case			(       self )		->     Tuple:
            super().test_inference_batch_single_identical(expected_max_diff=3e-3 )







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





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





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

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

            lowerCAmelCase  						=       """a hat"""

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

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

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

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

            lowerCAmelCase  						=       output.images[0]

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

            assert_mean_pixel_difference(lowercase      ,						lowercase )








"""simple docstring"""



def 					_UpperCAmelCase      ( __lowerCamelCase   :       int = 1_00_00_00		)     ->					int:
  _snake_case					     =       limit + 1
  _snake_case					     =       [0] * limit
  for first_term in range(1 ,					__lowerCamelCase		):
    for n in range(__lowerCamelCase ,					__lowerCamelCase ,					__lowerCamelCase		):
      _snake_case					     =       first_term + n / first_term
      if common_difference % 4:  # d must be divisble by 4
        continue
      else:
        common_difference /= 4
        if (
            first_term > common_difference
            and first_term < 4 * common_difference
        ):  # since x,y,z are positive integers
          frequency[n] += 1  # so z>0 and a>d ,also 4d<a

  _snake_case					     =       sum(1 for x in frequency[1:limit] if x == 10		)

  return count


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



