

"""simple docstring"""




import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image

from diffusers import (
    DDIMScheduler,
    KandinskyVaaControlnetImgaImgPipeline,
    KandinskyVaaPriorEmbaEmbPipeline,
    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       (			__a				,       unittest.TestCase					):
      __a								=	KandinskyVaaControlnetImgaImgPipeline
      __a								=	['image_embeds', 'negative_image_embeds', 'image', 'hint']
      __a								=	['image_embeds', 'negative_image_embeds', 'image', 'hint']
      __a								=	[
          'generator',
          'height',
          'width',
          'strength',
          'guidance_scale',
          'num_inference_steps',
          'return_dict',
          'guidance_scale',
          'num_images_per_prompt',
          'output_type',
          'return_dict',
      ]
      __a								=	False





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





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





      @property
      def 					_lowerCamelCase  (  self		)   ->					Any:
         return self.time_input_dim





      @property
      def 					_lowerCamelCase  (  self		)   ->					Dict:
         return self.time_input_dim * 4





      @property
      def 					_lowerCamelCase  (  self		)   ->					Any:
         return 100





      @property
      def 					_lowerCamelCase  (  self		)   ->					Any:
         torch.manual_seed(0		)

         lowerCamelCase__						=			{
             "in_channels": 8,
             # Out channels is double in channels because predicts mean and variance
             "out_channels": 8,
             "addition_embed_type": "image_hint",
             "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(**SCREAMING_SNAKE_CASE__		)
         return model





      @property
      def 					_lowerCamelCase  (  self		)   ->					Dict:
         return {
             "block_out_channels": [32, 32, 64, 64],
             "down_block_types": [
                 "DownEncoderBlock2D",
                 "DownEncoderBlock2D",
                 "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", "UpDecoderBlock2D", "UpDecoderBlock2D"],
             "vq_embed_dim": 4,
         }





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





      def 					_lowerCamelCase  (  self		)   ->					Union[str, Any]:
         lowerCamelCase__						=			self.dummy_unet
         lowerCamelCase__						=			self.dummy_movq

         lowerCamelCase__						=			{
             "num_train_timesteps": 1000,
             "beta_schedule": "linear",
             "beta_start": 0.0_00_85,
             "beta_end": 0.0_12,
             "clip_sample": False,
             "set_alpha_to_one": False,
             "steps_offset": 0,
             "prediction_type": "epsilon",
             "thresholding": False,
         }

         lowerCamelCase__						=			DDIMScheduler(**SCREAMING_SNAKE_CASE__		)

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

         return components





      def 					_lowerCamelCase  (  self    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__=0		)   ->					List[str]:
         lowerCamelCase__						=			floats_tensor((1, self.text_embedder_hidden_size)    ,						rng=random.Random(SCREAMING_SNAKE_CASE__		)		).to(SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			floats_tensor((1, self.text_embedder_hidden_size)    ,						rng=random.Random(seed + 1		)		).to(
             SCREAMING_SNAKE_CASE__		)
         # create init_image
         lowerCamelCase__						=			floats_tensor((1, 3, 64, 64)    ,						rng=random.Random(SCREAMING_SNAKE_CASE__		)		).to(SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			image.cpu().permute(0    ,						2    ,						3    ,						1		)[0]
         lowerCamelCase__						=			Image.fromarray(np.uinta(SCREAMING_SNAKE_CASE__		)		).convert("RGB"		).resize((256, 256)		)
         # create hint
         lowerCamelCase__						=			floats_tensor((1, 3, 64, 64)    ,						rng=random.Random(SCREAMING_SNAKE_CASE__		)		).to(SCREAMING_SNAKE_CASE__		)

         if str(SCREAMING_SNAKE_CASE__		).startswith("mps"		):
            lowerCamelCase__						=			torch.manual_seed(SCREAMING_SNAKE_CASE__		)
         else:
            lowerCamelCase__						=			torch.Generator(device=SCREAMING_SNAKE_CASE__		).manual_seed(SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			{
             "image": init_image,
             "image_embeds": image_embeds,
             "negative_image_embeds": negative_image_embeds,
             "hint": hint,
             "generator": generator,
             "height": 64,
             "width": 64,
             "num_inference_steps": 10,
             "guidance_scale": 7.0,
             "strength": 0.2,
             "output_type": "np",
         }
         return inputs





      def 					_lowerCamelCase  (  self		)   ->					Union[str, Any]:
         lowerCamelCase__						=			"cpu"

         lowerCamelCase__						=			self.get_dummy_components()

         lowerCamelCase__						=			self.pipeline_class(**SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			pipe.to(SCREAMING_SNAKE_CASE__		)

         pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						=			pipe(**self.get_dummy_inputs(SCREAMING_SNAKE_CASE__		)		)
         lowerCamelCase__						=			output.images

         lowerCamelCase__						=			pipe(
             **self.get_dummy_inputs(SCREAMING_SNAKE_CASE__		)    ,						return_dict=SCREAMING_SNAKE_CASE__    ,						)[0]

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

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

         lowerCamelCase__						=			np.array(
             [0.54_98_50_34, 0.55_50_93_65, 0.52_56_15_04, 0.5_57_04_94, 0.5_59_38_18, 0.5_26_39_79, 0.50_28_56_43, 0.5_06_98_46, 0.51_19_67_36]		)
         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 		_A       (			unittest.TestCase					):





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





      def 					_lowerCamelCase  (  self		)   ->					int:
         lowerCamelCase__						=			load_numpy(
             "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
             "/kandinskyv22/kandinskyv22_controlnet_img2img_robotcat_fp16.npy"		)

         lowerCamelCase__						=			load_image(
             "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main" "/kandinsky/cat.png"		)
         lowerCamelCase__						=			init_image.resize((512, 512)		)

         lowerCamelCase__						=			load_image(
             "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
             "/kandinskyv22/hint_image_cat.png"		)
         lowerCamelCase__						=			torch.from_numpy(np.array(SCREAMING_SNAKE_CASE__		)		).float() / 2_55.0
         lowerCamelCase__						=			hint.permute(2    ,						0    ,						1		).unsqueeze(0		)

         lowerCamelCase__						=			"A robot, 4k photo"

         lowerCamelCase__						=			KandinskyVaaPriorEmbaEmbPipeline.from_pretrained(
             "kandinsky-community/kandinsky-2-2-prior"    ,						torch_dtype=torch.floataa		)
         pipe_prior.to(SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						=			KandinskyVaaControlnetImgaImgPipeline.from_pretrained(
             "kandinsky-community/kandinsky-2-2-controlnet-depth"    ,						torch_dtype=torch.floataa		)
         lowerCamelCase__						=			pipeline.to(SCREAMING_SNAKE_CASE__		)

         pipeline.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						=			torch.Generator(device="cpu"		).manual_seed(0		)

         lowerCamelCase__					,       lowerCamelCase__						=			pipe_prior(
             SCREAMING_SNAKE_CASE__    ,						image=SCREAMING_SNAKE_CASE__    ,						strength=0.85    ,						generator=SCREAMING_SNAKE_CASE__    ,						negative_prompt=""    ,						).to_tuple()

         lowerCamelCase__						=			pipeline(
             image=SCREAMING_SNAKE_CASE__    ,						image_embeds=SCREAMING_SNAKE_CASE__    ,						negative_image_embeds=SCREAMING_SNAKE_CASE__    ,						hint=SCREAMING_SNAKE_CASE__    ,						generator=SCREAMING_SNAKE_CASE__    ,						num_inference_steps=100    ,						height=512    ,						width=512    ,						strength=0.5    ,						output_type="np"    ,						)

         lowerCamelCase__						=			output.images[0]

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

         assert_mean_pixel_difference(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__		)







"""simple docstring"""




import gc
import unittest

from diffusers import FlaxControlNetModel, FlaxStableDiffusionControlNetPipeline
from diffusers.utils import is_flax_available, load_image, slow
from diffusers.utils.testing_utils import require_flax


if is_flax_available():
     import jax
     import jax.numpy as jnp
     from flax.jax_utils import replicate
     from flax.training.common_utils import shard


@slow
@require_flax
class 		_A       (			unittest.TestCase					):





      def 					_lowerCamelCase  (  self		)   ->					Tuple:
         # clean up the VRAM after each test
         super().tearDown()
         gc.collect()





      def 					_lowerCamelCase  (  self		)   ->					Optional[Any]:
         lowerCamelCase__					,       lowerCamelCase__						=			FlaxControlNetModel.from_pretrained(
             "lllyasviel/sd-controlnet-canny"    ,						from_pt=SCREAMING_SNAKE_CASE__    ,						dtype=jnp.bfloataa		)
         lowerCamelCase__					,       lowerCamelCase__						=			FlaxStableDiffusionControlNetPipeline.from_pretrained(
             "runwayml/stable-diffusion-v1-5"    ,						controlnet=SCREAMING_SNAKE_CASE__    ,						from_pt=SCREAMING_SNAKE_CASE__    ,						dtype=jnp.bfloataa		)
         lowerCamelCase__						=			controlnet_params

         lowerCamelCase__						=			"bird"
         lowerCamelCase__						=			jax.device_count()
         lowerCamelCase__						=			pipe.prepare_text_inputs([prompts] * num_samples		)

         lowerCamelCase__						=			load_image(
             "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png"		)
         lowerCamelCase__						=			pipe.prepare_image_inputs([canny_image] * num_samples		)

         lowerCamelCase__						=			jax.random.PRNGKey(0		)
         lowerCamelCase__						=			jax.random.split(SCREAMING_SNAKE_CASE__    ,						jax.device_count()		)

         lowerCamelCase__						=			replicate(SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			shard(SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			shard(SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						=			pipe(
             prompt_ids=SCREAMING_SNAKE_CASE__    ,						image=SCREAMING_SNAKE_CASE__    ,						params=SCREAMING_SNAKE_CASE__    ,						prng_seed=SCREAMING_SNAKE_CASE__    ,						num_inference_steps=50    ,						jit=SCREAMING_SNAKE_CASE__    ,						).images
         assert images.shape == (jax.device_count(), 1, 768, 512, 3)

         lowerCamelCase__						=			images.reshape((images.shape[0] * images.shape[1],) + images.shape[-3:]		)
         lowerCamelCase__						=			images[0, 253:256, 253:256, -1]

         lowerCamelCase__						=			jnp.asarray(jax.device_get(image_slice.flatten()		)		)
         lowerCamelCase__						=			jnp.array(
             [0.16_79_69, 0.11_66_99, 0.08_15_43, 0.15_42_97, 0.13_28_12, 0.10_88_87, 0.16_99_22, 0.16_99_22, 0.20_50_78]		)
         print(f'output_slice: {output_slice}'		)
         assert jnp.abs(output_slice - expected_slice		).max() < 1e-2





      def 					_lowerCamelCase  (  self		)   ->					str:
         lowerCamelCase__					,       lowerCamelCase__						=			FlaxControlNetModel.from_pretrained(
             "lllyasviel/sd-controlnet-openpose"    ,						from_pt=SCREAMING_SNAKE_CASE__    ,						dtype=jnp.bfloataa		)
         lowerCamelCase__					,       lowerCamelCase__						=			FlaxStableDiffusionControlNetPipeline.from_pretrained(
             "runwayml/stable-diffusion-v1-5"    ,						controlnet=SCREAMING_SNAKE_CASE__    ,						from_pt=SCREAMING_SNAKE_CASE__    ,						dtype=jnp.bfloataa		)
         lowerCamelCase__						=			controlnet_params

         lowerCamelCase__						=			"Chef in the kitchen"
         lowerCamelCase__						=			jax.device_count()
         lowerCamelCase__						=			pipe.prepare_text_inputs([prompts] * num_samples		)

         lowerCamelCase__						=			load_image(
             "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/pose.png"		)
         lowerCamelCase__						=			pipe.prepare_image_inputs([pose_image] * num_samples		)

         lowerCamelCase__						=			jax.random.PRNGKey(0		)
         lowerCamelCase__						=			jax.random.split(SCREAMING_SNAKE_CASE__    ,						jax.device_count()		)

         lowerCamelCase__						=			replicate(SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			shard(SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						=			shard(SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						=			pipe(
             prompt_ids=SCREAMING_SNAKE_CASE__    ,						image=SCREAMING_SNAKE_CASE__    ,						params=SCREAMING_SNAKE_CASE__    ,						prng_seed=SCREAMING_SNAKE_CASE__    ,						num_inference_steps=50    ,						jit=SCREAMING_SNAKE_CASE__    ,						).images
         assert images.shape == (jax.device_count(), 1, 768, 512, 3)

         lowerCamelCase__						=			images.reshape((images.shape[0] * images.shape[1],) + images.shape[-3:]		)
         lowerCamelCase__						=			images[0, 253:256, 253:256, -1]

         lowerCamelCase__						=			jnp.asarray(jax.device_get(image_slice.flatten()		)		)
         lowerCamelCase__						=			jnp.array(
             [[0.27_14_84, 0.26_17_19, 0.27_53_91, 0.27_73_44, 0.27_92_97, 0.29_10_16, 0.29_49_22, 0.30_27_34, 0.30_27_34]]		)
         print(f'output_slice: {output_slice}'		)
         assert jnp.abs(output_slice - expected_slice		).max() < 1e-2




