




'''simple docstring'''



import gc
import random
import unittest

import numpy as np
import torch

from diffusers import (
    DDIMScheduler,
    KandinskyVaaControlnetPipeline,
    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							(       __snake_case      ,	unittest.TestCase      ):





       '''simple docstring'''






       A		:							int								=		KandinskyVaaControlnetPipeline
       A		:							Dict								=		['image_embeds', 'negative_image_embeds', 'hint']
       A		:							Tuple								=		['image_embeds', 'negative_image_embeds', 'hint']
       A		:							str								=		[
           'generator',
           'height',
           'width',
           'latents',
           'guidance_scale',
           'num_inference_steps',
           'return_dict',
           'guidance_scale',
           'num_images_per_prompt',
           'output_type',
           'return_dict',
       ]
       A		:							Optional[int]								=		False







       @property
       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             return 32







       @property
       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             return 32







       @property
       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             return self.time_input_dim







       @property
       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             return self.time_input_dim * 4







       @property
       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             return 100







       @property
       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             torch.manual_seed(0   )

             SCREAMING_SNAKE_CASE					:	Optional[int]   =		{
                 "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,
             }

             SCREAMING_SNAKE_CASE					:	Dict   =		UNetaDConditionModel(**A_   )
             return model







       @property
       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             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     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             torch.manual_seed(0   )
             SCREAMING_SNAKE_CASE					:	Any   =		VQModel(**self.dummy_movq_kwargs   )
             return model







       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE					:	Dict   =		self.dummy_unet
             SCREAMING_SNAKE_CASE					:	Optional[int]   =		self.dummy_movq

             SCREAMING_SNAKE_CASE					:	Optional[int]   =		DDIMScheduler(
                 num_train_timesteps=1_000,				beta_schedule='linear',				beta_start=0.0_00_85,				beta_end=0.0_12,				clip_sample=A_,				set_alpha_to_one=A_,				steps_offset=1,				prediction_type='epsilon',				thresholding=A_,				)

             SCREAMING_SNAKE_CASE					:	List[Any]   =		{
                 "unet": unet,
                 "scheduler": scheduler,
                 "movq": movq,
             }
             return components







       def     UpperCamelCase_				(	self,				A,				A=0   ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE					:	Tuple   =		floats_tensor((1, self.text_embedder_hidden_size),				rng=random.Random(A_   )   ).to(A_   )
             SCREAMING_SNAKE_CASE					:	Optional[Any]   =		floats_tensor((1, self.text_embedder_hidden_size),				rng=random.Random(seed + 1   )   ).to(
                 A_   )

             # create hint
             SCREAMING_SNAKE_CASE					:	List[str]   =		floats_tensor((1, 3, 64, 64),				rng=random.Random(A_   )   ).to(A_   )

             if str(A_   ).startswith('mps'   ):
                   SCREAMING_SNAKE_CASE					:	int   =		torch.manual_seed(A_   )
             else:
                   SCREAMING_SNAKE_CASE					:	Union[str, Any]   =		torch.Generator(device=A_   ).manual_seed(A_   )
             SCREAMING_SNAKE_CASE					:	Dict   =		{
                 "image_embeds": image_embeds,
                 "negative_image_embeds": negative_image_embeds,
                 "hint": hint,
                 "generator": generator,
                 "height": 64,
                 "width": 64,
                 "guidance_scale": 4.0,
                 "num_inference_steps": 2,
                 "output_type": "np",
             }
             return inputs







       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE					:	int   =		"cpu"

             SCREAMING_SNAKE_CASE					:	Dict   =		self.get_dummy_components()

             SCREAMING_SNAKE_CASE					:	int   =		self.pipeline_class(**A_   )
             SCREAMING_SNAKE_CASE					:	Any   =		pipe.to(A_   )

             pipe.set_progress_bar_config(disable=A_   )

             SCREAMING_SNAKE_CASE					:	int   =		pipe(**self.get_dummy_inputs(A_   )   )
             SCREAMING_SNAKE_CASE					:	Tuple   =		output.images

             SCREAMING_SNAKE_CASE					:	List[str]   =		pipe(
                 **self.get_dummy_inputs(A_   ),				return_dict=A_,				)[0]

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

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

             SCREAMING_SNAKE_CASE					:	str   =		np.array(
                 [0.6_95_98_26, 0.86_82_79, 0.7_55_80_92, 0.68_76_94_67, 0.85_80_58_04, 0.65_97_74_96, 0.44_88_53_02, 0.5_95_91_11, 0.4_25_15_95]   )

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





       '''simple docstring'''






       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







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







       def     UpperCamelCase_				(	self   ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE					:	Dict   =		load_numpy(
                 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
                 '/kandinskyv22/kandinskyv22_controlnet_robotcat_fp16.npy'   )

             SCREAMING_SNAKE_CASE					:	Union[str, Any]   =		load_image(
                 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
                 '/kandinskyv22/hint_image_cat.png'   )
             SCREAMING_SNAKE_CASE					:	Optional[int]   =		torch.from_numpy(np.array(A_   )   ).float() / 255.0
             SCREAMING_SNAKE_CASE					:	Tuple   =		hint.permute(2,				0,				1   ).unsqueeze(0   )

             SCREAMING_SNAKE_CASE					:	Optional[int]   =		KandinskyVaaPriorPipeline.from_pretrained(
                 'kandinsky-community/kandinsky-2-2-prior',				torch_dtype=torch.floataa   )
             pipe_prior.to(A_   )

             SCREAMING_SNAKE_CASE					:	Optional[int]   =		KandinskyVaaControlnetPipeline.from_pretrained(
                 'kandinsky-community/kandinsky-2-2-controlnet-depth',				torch_dtype=torch.floataa   )
             SCREAMING_SNAKE_CASE					:	Tuple   =		pipeline.to(A_   )
             pipeline.set_progress_bar_config(disable=A_   )

             SCREAMING_SNAKE_CASE					:	str   =		"A robot, 4k photo"

             SCREAMING_SNAKE_CASE					:	Optional[Any]   =		torch.Generator(device='cuda'   ).manual_seed(0   )
             SCREAMING_SNAKE_CASE					:	Dict   =		pipe_prior(
                 A_,				generator=A_,				num_inference_steps=5,				negative_prompt='',				).to_tuple()

             SCREAMING_SNAKE_CASE					:	int   =		torch.Generator(device='cuda'   ).manual_seed(0   )
             SCREAMING_SNAKE_CASE					:	str   =		pipeline(
                 image_embeds=A_,				negative_image_embeds=A_,				hint=A_,				generator=A_,				num_inference_steps=100,				output_type='np',				)

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

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

             assert_mean_pixel_difference(A_,				A_   )









def 		A_				(     _lowerCAmelCase = 50     )						-> int:
 UpperCamelCase	:					List[Any]       	=   [[0] * 3 for _ in range(length + 1     )]

 for row_length in range(length + 1     ):
  for tile_length in range(2							,   5     ):
   for tile_start in range(row_length - tile_length + 1     ):
    different_colour_ways_number[row_length][tile_length - 2] += (
        different_colour_ways_number[row_length - tile_start - tile_length][
            tile_length - 2
        ]
        + 1
    )

 return sum(different_colour_ways_number[length]     )


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