






import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image

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







     '''simple docstring'''
     SCREAMING_SNAKE_CASE   						=				KandinskyVaaImgaImgPipeline
     SCREAMING_SNAKE_CASE   						=				["image_embeds", "negative_image_embeds", "image"]
     SCREAMING_SNAKE_CASE   						=				[
         "image_embeds",
         "negative_image_embeds",
         "image",
     ]
     SCREAMING_SNAKE_CASE   						=				[
         "generator",
         "height",
         "width",
         "strength",
         "guidance_scale",
         "num_inference_steps",
         "return_dict",
         "guidance_scale",
         "num_images_per_prompt",
         "output_type",
         "return_dict",
     ]
     SCREAMING_SNAKE_CASE   						=				False




     @property
     def 		lowerCAmelCase_     (				self       :			Tuple				):


         """simple docstring"""



         return 32




     @property
     def 		lowerCAmelCase_     (				self       :			Tuple				):


         """simple docstring"""



         return 32




     @property
     def 		lowerCAmelCase_     (				self       :			Dict				):


         """simple docstring"""



         return self.time_input_dim




     @property
     def 		lowerCAmelCase_     (				self       :			str				):


         """simple docstring"""



         return self.time_input_dim * 4




     @property
     def 		lowerCAmelCase_     (				self       :			Dict				):


         """simple docstring"""



         return 100




     @property
     def 		lowerCAmelCase_     (				self       :			int				):


         """simple docstring"""



         torch.manual_seed(0				)

         __A         =	{
             """in_channels""": 4,
             # 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,
         }

         __A         =	UNetaDConditionModel(**UpperCamelCase_				)
         return model




     @property
     def 		lowerCAmelCase_     (				self       :			List[Any]				):


         """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 		lowerCAmelCase_     (				self       :			Optional[int]				):


         """simple docstring"""



         torch.manual_seed(0				)
         __A         =	VQModel(**self.dummy_movq_kwargs				)
         return model




     def 		lowerCAmelCase_     (				self       :			Tuple				):


         """simple docstring"""



         __A         =	self.dummy_unet
         __A         =	self.dummy_movq

         __A         =	{
             """num_train_timesteps""": 1_000,
             """beta_schedule""": """linear""",
             """beta_start""": 0.00085,
             """beta_end""": 0.012,
             """clip_sample""": False,
             """set_alpha_to_one""": False,
             """steps_offset""": 0,
             """prediction_type""": """epsilon""",
             """thresholding""": False,
         }

         __A         =	DDIMScheduler(**UpperCamelCase_				)

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

         return components




     def 		lowerCAmelCase_     (				self       :			str ,	UpperCamelCase_       :			Tuple ,	UpperCamelCase_       :			Tuple=0				):


         """simple docstring"""



         __A         =	floats_tensor((1, self.text_embedder_hidden_size) ,	rng=random.Random(UpperCamelCase_				)				).to(UpperCamelCase_				)
         __A         =	floats_tensor((1, self.text_embedder_hidden_size) ,	rng=random.Random(seed + 1				)				).to(
             UpperCamelCase_				)
         # create init_image
         __A         =	floats_tensor((1, 3, 64, 64) ,	rng=random.Random(UpperCamelCase_				)				).to(UpperCamelCase_				)
         __A         =	image.cpu().permute(0 ,	2 ,	3 ,	1				)[0]
         __A         =	Image.fromarray(np.uinta(UpperCamelCase_				)				).convert("""RGB"""				).resize((256, 256)				)

         if str(UpperCamelCase_				).startswith("""mps"""				):
             __A         =	torch.manual_seed(UpperCamelCase_				)
         else:
             __A         =	torch.Generator(device=UpperCamelCase_				).manual_seed(UpperCamelCase_				)
         __A         =	{
             """image""": init_image,
             """image_embeds""": image_embeds,
             """negative_image_embeds""": negative_image_embeds,
             """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       :			Optional[Any]				):


         """simple docstring"""



         __A         =	"""cpu"""

         __A         =	self.get_dummy_components()

         __A         =	self.pipeline_class(**UpperCamelCase_				)
         __A         =	pipe.to(UpperCamelCase_				)

         pipe.set_progress_bar_config(disable=UpperCamelCase_				)

         __A         =	pipe(**self.get_dummy_inputs(UpperCamelCase_				)				)
         __A         =	output.images

         __A         =	pipe(
             **self.get_dummy_inputs(UpperCamelCase_				) ,	return_dict=UpperCamelCase_ ,	)[0]

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

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

         __A         =	np.array(
             [0.6199778, 0.63984406, 0.46145785, 0.62944984, 0.5622215, 0.47306132, 0.47441456, 0.4607606, 0.48719263]				)
         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       __lowercase      (	unittest.TestCase  ):







     '''simple docstring'''




     def 		lowerCAmelCase_     (				self       :			Optional[Any]				):


         """simple docstring"""



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





     def 		lowerCAmelCase_     (				self       :			Any				):


         """simple docstring"""



         __A         =	load_numpy(
             """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
             """/kandinskyv22/kandinskyv22_img2img_frog.npy"""				)

         __A         =	load_image(
             """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main""" """/kandinsky/cat.png"""				)
         __A         =	"""A red cartoon frog, 4k"""

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

         __A         =	KandinskyVaaImgaImgPipeline.from_pretrained(
             """kandinsky-community/kandinsky-2-2-decoder""" ,	torch_dtype=torch.floataa				)
         __A         =	pipeline.to(UpperCamelCase_				)

         pipeline.set_progress_bar_config(disable=UpperCamelCase_				)

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

         __A         =	pipeline(
             image=UpperCamelCase_ ,	image_embeds=UpperCamelCase_ ,	negative_image_embeds=UpperCamelCase_ ,	generator=UpperCamelCase_ ,	num_inference_steps=100 ,	height=768 ,	width=768 ,	strength=0.2 ,	output_type="""np""" ,	)

         __A         =	output.images[0]

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

         assert_mean_pixel_difference(UpperCamelCase_ ,	UpperCamelCase_				)














__a      :       List[Any]				  =   8.3_1_4_4_5_9_8



def 			_SCREAMING_SNAKE_CASE						( __lowercase   :			float			,				__lowercase   :			float    )						->      float:





    """simple docstring"""

    if temperature < 0:
        raise Exception("""Temperature cannot be less than 0 K"""    )
    if molar_mass <= 0:
        raise Exception("""Molar mass cannot be less than or equal to 0 kg/mol"""    )
    else:
        return (3 * UNIVERSAL_GAS_CONSTANT * temperature / molar_mass) ** 0.5


if __name__ == "__main__":
  import doctest

  # run doctest
  doctest.testmod()

  # example
  __a      :       int				  =   300
  __a      :       int				  =   28
  __a      :       int				  =   rms_speed_of_molecule(temperature, molar_mass)
  print(f"""Vrms of Nitrogen gas at 300 K is {vrms} m/s""")




