



"""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     (			snake_case ,					unittest.TestCase    ):




	"""simple docstring"""
	SCREAMING_SNAKE_CASE_				:    Dict		    =   KandinskyPipeline
	SCREAMING_SNAKE_CASE_				:    Tuple		    =   [
	    "prompt",
	    "image_embeds",
	    "negative_image_embeds",
	]
	SCREAMING_SNAKE_CASE_				:    int		    =   ["prompt", "negative_prompt", "image_embeds", "negative_image_embeds"]
	SCREAMING_SNAKE_CASE_				:    Tuple		    =   [
	    "generator",
	    "height",
	    "width",
	    "latents",
	    "guidance_scale",
	    "negative_prompt",
	    "num_inference_steps",
	    "return_dict",
	    "guidance_scale",
	    "num_images_per_prompt",
	    "output_type",
	    "return_dict",
	]
	SCREAMING_SNAKE_CASE_				:    str		    =   False






	@property
	def 					lowerCamelCase__ (			self					):
			return 32






	@property
	def 					lowerCamelCase__ (			self					):
			return 32






	@property
	def 					lowerCamelCase__ (			self					):
			return self.time_input_dim






	@property
	def 					lowerCamelCase__ (			self					):
			return self.time_input_dim * 4






	@property
	def 					lowerCamelCase__ (			self					):
			return 1_00






	@property
	def 					lowerCamelCase__ (			self					):
			_lowercase							:      List[Any]			=					XLMRobertaTokenizerFast.from_pretrained("""YiYiXu/tiny-random-mclip-base"""					)
			return tokenizer






	@property
	def 					lowerCamelCase__ (			self					):
			torch.manual_seed(0					)
			_lowercase							:      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=10_05							,)

			_lowercase							:      str			=					MultilingualCLIP(UpperCAmelCase_					)
			_lowercase							:      Tuple			=					text_encoder.eval()

			return text_encoder






	@property
	def 					lowerCamelCase__ (			self					):
			torch.manual_seed(0					)

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

			_lowercase							:      Optional[int]			=					UNetaDConditionModel(**UpperCAmelCase_					)
			return model






	@property
	def 					lowerCamelCase__ (			self					):
			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 					lowerCamelCase__ (			self					):
			torch.manual_seed(0					)
			_lowercase							:      Any			=					VQModel(**self.dummy_movq_kwargs					)
			return model






	def 					lowerCamelCase__ (			self					):
			_lowercase							:      int			=					self.dummy_text_encoder
			_lowercase							:      List[str]			=					self.dummy_tokenizer
			_lowercase							:      Any			=					self.dummy_unet
			_lowercase							:      int			=					self.dummy_movq

			_lowercase							:      List[Any]			=					DDIMScheduler(
			    num_train_timesteps=10_00							,beta_schedule="""linear"""							,beta_start=0.00085							,beta_end=0.012							,clip_sample=UpperCAmelCase_							,set_alpha_to_one=UpperCAmelCase_							,steps_offset=1							,prediction_type="""epsilon"""							,thresholding=UpperCAmelCase_							,)

			_lowercase							:      Optional[Any]			=					{
			    """text_encoder""": text_encoder,
			    """tokenizer""": tokenizer,
			    """unet""": unet,
			    """scheduler""": scheduler,
			    """movq""": movq,
			}
			return components






	def 					lowerCamelCase__ (			self							,UpperCAmelCase_							,UpperCAmelCase_=0					):
			_lowercase							:      int			=					floats_tensor((1, self.cross_attention_dim)							,rng=random.Random(UpperCAmelCase_					)					).to(UpperCAmelCase_					)
			_lowercase							:      str			=					floats_tensor((1, self.cross_attention_dim)							,rng=random.Random(seed + 1					)					).to(UpperCAmelCase_					)
			if str(UpperCAmelCase_					).startswith("""mps"""					):
					_lowercase							:      Dict			=					torch.manual_seed(UpperCAmelCase_					)
			else:
					_lowercase							:      List[Any]			=					torch.Generator(device=UpperCAmelCase_					).manual_seed(UpperCAmelCase_					)
			_lowercase							:      List[str]			=					{
			    """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 					lowerCamelCase__ (			self					):
			_lowercase							:      Any			=					"""cpu"""

			_lowercase							:      Tuple			=					self.get_dummy_components()

			_lowercase							:      List[str]			=					self.pipeline_class(**UpperCAmelCase_					)
			_lowercase							:      Optional[Any]			=					pipe.to(UpperCAmelCase_					)

			pipe.set_progress_bar_config(disable=UpperCAmelCase_					)

			_lowercase							:      Optional[Any]			=					pipe(**self.get_dummy_inputs(UpperCAmelCase_					)					)
			_lowercase							:      Dict			=					output.images

			_lowercase							:      Any			=					pipe(
			    **self.get_dummy_inputs(UpperCAmelCase_					)							,return_dict=UpperCAmelCase_							,)[0]

			_lowercase							:      Any			=					image[0, -3:, -3:, -1]
			_lowercase							:      Any			=					image_from_tuple[0, -3:, -3:, -1]

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

			_lowercase							:      Dict			=					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    ):




	"""simple docstring"""






	def 					lowerCamelCase__ (			self					):
			# clean up the VRAM after each test
			super().tearDown()
			gc.collect()
			torch.cuda.empty_cache()






	def 					lowerCamelCase__ (			self					):
			_lowercase							:      Any			=					load_numpy(
			    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
			    """/kandinsky/kandinsky_text2img_cat_fp16.npy"""					)

			_lowercase							:      int			=					KandinskyPriorPipeline.from_pretrained(
			    """kandinsky-community/kandinsky-2-1-prior"""							,torch_dtype=torch.floataa					)
			pipe_prior.to(UpperCAmelCase_					)

			_lowercase							:      Union[str, Any]			=					KandinskyPipeline.from_pretrained("""kandinsky-community/kandinsky-2-1"""							,torch_dtype=torch.floataa					)
			_lowercase							:      Tuple			=					pipeline.to(UpperCAmelCase_					)
			pipeline.set_progress_bar_config(disable=UpperCAmelCase_					)

			_lowercase							:      List[Any]			=					"""red cat, 4k photo"""

			_lowercase							:      Optional[int]			=					torch.Generator(device="""cuda"""					).manual_seed(0					)
			_lowercase			,   _lowercase							:      Any			=					pipe_prior(
			    UpperCAmelCase_							,generator=UpperCAmelCase_							,num_inference_steps=5							,negative_prompt=""""""							,).to_tuple()

			_lowercase							:      Dict			=					torch.Generator(device="""cuda"""					).manual_seed(0					)
			_lowercase							:      Optional[int]			=					pipeline(
			    UpperCAmelCase_							,image_embeds=UpperCAmelCase_							,negative_image_embeds=UpperCAmelCase_							,generator=UpperCAmelCase_							,num_inference_steps=1_00							,output_type="""np"""							,)

			_lowercase							:      int			=					output.images[0]

			assert image.shape == (5_12, 5_12, 3)

			assert_mean_pixel_difference(UpperCAmelCase_							,UpperCAmelCase_					)








"""simple docstring"""







import unittest
from pathlib import Path
from tempfile import TemporaryDirectory
from unittest.mock import Mock, patch

import diffusers.utils.hub_utils





class    UpperCamelCase     (			unittest.TestCase    ):




	"""simple docstring"""






	@patch("""diffusers.utils.hub_utils.get_full_repo_name"""					)
	def 					lowerCamelCase__ (			self							,UpperCAmelCase_					):
			_lowercase							:      List[Any]			=					"""full_repo_name"""
			with TemporaryDirectory() as tmpdir:
					# Dummy args values
					_lowercase							:      Optional[Any]			=					Mock()
					_lowercase							:      int			=					tmpdir
					_lowercase							:      int			=					0
					_lowercase							:      Optional[Any]			=					"""hub_token"""
					_lowercase							:      Optional[Any]			=					"""dataset_name"""
					_lowercase							:      List[Any]			=					0.01
					_lowercase							:      Tuple			=					10_00_00
					_lowercase							:      Optional[Any]			=					1_00_00
					_lowercase							:      Optional[int]			=					0.01
					_lowercase							:      Tuple			=					0.02
					_lowercase							:      int			=					0.03
					_lowercase							:      Optional[int]			=					0.0005
					_lowercase							:      Tuple			=					0.000001
					_lowercase							:      int			=					1
					_lowercase							:      List[str]			=					10
					_lowercase							:      Optional[Any]			=					0.001
					_lowercase							:      int			=					0.1
					_lowercase							:      Optional[Any]			=					0.2
					_lowercase							:      Tuple			=					True

					# Model card mush be rendered and saved
					diffusers.utils.hub_utils.create_model_card(UpperCAmelCase_							,model_name="""model_name"""					)
					self.assertTrue((Path(UpperCAmelCase_					) / """README.md""").is_file()					)



