code: 
  
  
  '''simple docstring'''
  
  
  
  import gc
  import random
  import unittest
  
  import numpy as np
  import torch
  from transformers import XLMRobertaTokenizerFast
  
  from diffusers import DDIMScheduler, KandinskyPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel
  from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP
  from diffusers.utils import floats_tensor, 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 							__UpperCamelCase       (	lowerCAmelCase_	,   unittest.TestCase      ):
  	A_			    =					KandinskyPipeline
  	A_			    =					[
  	    "prompt",
  	    "image_embeds",
  	    "negative_image_embeds",
  	]
  	A_			    =					["prompt", "negative_prompt", "image_embeds", "negative_image_embeds"]
  	A_			    =					[
  	    "generator",
  	    "height",
  	    "width",
  	    "latents",
  	    "guidance_scale",
  	    "negative_prompt",
  	    "num_inference_steps",
  	    "return_dict",
  	    "guidance_scale",
  	    "num_images_per_prompt",
  	    "output_type",
  	    "return_dict",
  	]
  	A_			    =					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'''
  
  
  
  
  
  						__a    : Union[str, Any]      					=						XLMRobertaTokenizerFast.from_pretrained('YiYiXu/tiny-random-mclip-base'							)
  						return tokenizer
  
  
  
  
  	@property
  	def    __UpperCAmelCase							(     self							):
  
  						'''simple docstring'''
  
  
  
  
  
  						torch.manual_seed(0							)
  						__a    : Dict      					=						MCLIPConfig(
  						    numDims=self.cross_attention_dim		,       transformerDimensions=self.text_embedder_hidden_size		,       hidden_size=self.text_embedder_hidden_size		,       intermediate_size=37		,       num_attention_heads=4		,       num_hidden_layers=5		,       vocab_size=1005		,       )
  
  						__a    : Dict      					=						MultilingualCLIP(__a							)
  						__a    : Optional[int]      					=						text_encoder.eval()
  
  						return text_encoder
  
  
  
  
  	@property
  	def    __UpperCAmelCase							(     self							):
  
  						'''simple docstring'''
  
  
  
  
  
  						torch.manual_seed(0							)
  
  						__a    : Union[str, Any]      					=						{
  						    'in_channels': 4,
  						    # Out channels is double in channels because predicts mean and variance
  						    'out_channels': 8,
  						    'addition_embed_type': 'text_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': 'text_image_proj',
  						    'cross_attention_dim': self.cross_attention_dim,
  						    'attention_head_dim': 4,
  						    'resnet_time_scale_shift': 'scale_shift',
  						    'class_embed_type': None,
  						}
  
  						__a    : Tuple      					=						UNetaDConditionModel(**__a							)
  						return model
  
  
  
  
  	@property
  	def    __UpperCAmelCase							(     self							):
  
  						'''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    __UpperCAmelCase							(     self							):
  
  						'''simple docstring'''
  
  
  
  
  
  						torch.manual_seed(0							)
  						__a    : Union[str, Any]      					=						VQModel(**self.dummy_movq_kwargs							)
  						return model
  
  
  
  
  	def    __UpperCAmelCase							(     self							):
  
  						'''simple docstring'''
  
  
  
  
  
  						__a    : Optional[Any]      					=						self.dummy_text_encoder
  						__a    : str      					=						self.dummy_tokenizer
  						__a    : List[str]      					=						self.dummy_unet
  						__a    : List[str]      					=						self.dummy_movq
  
  						__a    : str      					=						DDIMScheduler(
  						    num_train_timesteps=1000		,       beta_schedule='linear'		,       beta_start=0.00085		,       beta_end=0.012		,       clip_sample=__a		,       set_alpha_to_one=__a		,       steps_offset=1		,       prediction_type='epsilon'		,       thresholding=__a		,       )
  
  						__a    : List[str]      					=						{
  						    'text_encoder': text_encoder,
  						    'tokenizer': tokenizer,
  						    'unet': unet,
  						    'scheduler': scheduler,
  						    'movq': movq,
  						}
  						return components
  
  
  
  
  	def    __UpperCAmelCase							(     self		,       __a		,       __a=0							):
  
  						'''simple docstring'''
  
  
  
  
  
  						__a    : List[str]      					=						floats_tensor((1, self.cross_attention_dim)		,       rng=random.Random(__a							)							).to(__a							)
  						__a    : Union[str, Any]      					=						floats_tensor((1, self.cross_attention_dim)		,       rng=random.Random(seed + 1							)							).to(__a							)
  						if str(__a							).startswith('mps'							):
  											__a    : Any      					=						torch.manual_seed(__a							)
  						else:
  											__a    : Tuple      					=						torch.Generator(device=__a							).manual_seed(__a							)
  						__a    : Optional[int]      					=						{
  						    'prompt': 'horse',
  						    'image_embeds': image_embeds,
  						    'negative_image_embeds': negative_image_embeds,
  						    'generator': generator,
  						    'height': 64,
  						    'width': 64,
  						    'guidance_scale': 4.0,
  						    'num_inference_steps': 2,
  						    'output_type': 'np',
  						}
  						return inputs
  
  
  
  
  
  	def    __UpperCAmelCase							(     self							):
  
  						'''simple docstring'''
  
  
  
  
  
  						__a    : Any      					=						'cpu'
  
  						__a    : Union[str, Any]      					=						self.get_dummy_components()
  
  						__a    : Optional[Any]      					=						self.pipeline_class(**__a							)
  						__a    : Tuple      					=						pipe.to(__a							)
  
  						pipe.set_progress_bar_config(disable=__a							)
  
  						__a    : List[str]      					=						pipe(**self.get_dummy_inputs(__a							)							)
  						__a    : Tuple      					=						output.images
  
  						__a    : List[str]      					=						pipe(
  						    **self.get_dummy_inputs(__a							)		,       return_dict=__a		,       )[0]
  
  						__a    : List[Any]      					=						image[0, -3:, -3:, -1]
  						__a    : Tuple      					=						image_from_tuple[0, -3:, -3:, -1]
  
  						assert image.shape == (1, 64, 64, 3)
  
  						__a    : Union[str, Any]      					=						np.array(
  						    [0.328663, 1.0, 0.23216873, 1.0, 0.92717564, 0.4639046, 0.96894777, 0.31713378, 0.6293953]							)
  
  						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 							__UpperCamelCase       (	unittest.TestCase      ):
  
  
  
  
  	def    __UpperCAmelCase							(     self							):
  
  						'''simple docstring'''
  
  
  
  
  
  						super().tearDown()
  						gc.collect()
  						torch.cuda.empty_cache()
  
  
  
  
  
  	def    __UpperCAmelCase							(     self							):
  
  						'''simple docstring'''
  
  
  
  
  
  						__a    : Optional[int]      					=						load_numpy(
  						    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
  						    '/kandinsky/kandinsky_text2img_cat_fp16.npy'							)
  
  						__a    : Union[str, Any]      					=						KandinskyPriorPipeline.from_pretrained(
  						    'kandinsky-community/kandinsky-2-1-prior'		,       torch_dtype=torch.floataa							)
  						pipe_prior.to(__a							)
  
  						__a    : List[Any]      					=						KandinskyPipeline.from_pretrained('kandinsky-community/kandinsky-2-1'		,       torch_dtype=torch.floataa							)
  						__a    : str      					=						pipeline.to(__a							)
  						pipeline.set_progress_bar_config(disable=__a							)
  
  						__a    : Union[str, Any]      					=						'red cat, 4k photo'
  
  						__a    : Optional[Any]      					=						torch.Generator(device='cuda'							).manual_seed(0							)
  						__a					,       __a    : Union[str, Any]      					=						pipe_prior(
  						    __a		,       generator=__a		,       num_inference_steps=5		,       negative_prompt=''		,       ).to_tuple()
  
  						__a    : List[str]      					=						torch.Generator(device='cuda'							).manual_seed(0							)
  						__a    : Union[str, Any]      					=						pipeline(
  						    __a		,       image_embeds=__a		,       negative_image_embeds=__a		,       generator=__a		,       num_inference_steps=100		,       output_type='np'		,       )
  
  						__a    : str      					=						output.images[0]
  
  						assert image.shape == (512, 512, 3)
  
  						assert_mean_pixel_difference(__a		,       __a							)
  
  
  
  
style_context: 
  
  
  '''simple docstring'''
  
  
  
  import itertools
  
  
  
  
  
  
  def 						lowerCamelCase							(_SCREAMING_SNAKE_CASE   :     int = 1_000_000     ):
  					__a    : str      					=						[1]
  
  					for i in itertools.count(len(_SCREAMING_SNAKE_CASE     )     ):
  										__a    : Dict      					=						0
  										for j in itertools.count(1     ):
  															__a    : int      					=						-1 if j % 2 == 0 else +1
  															__a    : Optional[int]      					=						(j * j * 3 - j) // 2
  															if index > i:
  																				break
  															item += partitions[i - index] * sign
  															item %= number
  															index += j
  															if index > i:
  																				break
  															item += partitions[i - index] * sign
  															item %= number
  
  										if item == 0:
  															return i
  										partitions.append(_SCREAMING_SNAKE_CASE     )
  
  					return 0
  
  
  if __name__ == "__main__":
  	import doctest
  
  	doctest.testmod()
  
  	print(f'''{solution() = }''')
  
  
  
  