



import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    PNDMScheduler,
    StableDiffusionLDMaDPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import nightly, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS


enable_full_determinism()





class  lowerCamelCase__	(    unittest.TestCase):
     """simple docstring"""



     _A      =      StableDiffusionLDMaDPipeline
     _A      =      TEXT_TO_IMAGE_PARAMS
     _A      =      TEXT_TO_IMAGE_BATCH_PARAMS
     _A      =      TEXT_TO_IMAGE_IMAGE_PARAMS







     def     _a   (self     ):






           '''simple docstring'''



           torch.manual_seed(0     )
           lowerCamelCase             =		UNetaDConditionModel(
               block_out_channels=(32, 64)					,      layers_per_block=2					,      sample_size=32					,      in_channels=4					,      out_channels=4					,      down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")					,      up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")					,      cross_attention_dim=32					,      )
           lowerCamelCase             =		DDIMScheduler(
               beta_start=0.0_0085					,      beta_end=0.012					,      beta_schedule="scaled_linear"					,      clip_sample=__a					,      set_alpha_to_one=__a					,      )
           torch.manual_seed(0     )
           lowerCamelCase             =		AutoencoderKL(
               block_out_channels=[32, 64]					,      in_channels=6					,      out_channels=6					,      down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]					,      up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]					,      latent_channels=4					,      )
           torch.manual_seed(0     )
           lowerCamelCase             =		CLIPTextConfig(
               bos_token_id=0					,      eos_token_id=2					,      hidden_size=32					,      intermediate_size=37					,      layer_norm_eps=1E-05					,      num_attention_heads=4					,      num_hidden_layers=5					,      pad_token_id=1					,      vocab_size=10_00					,      )
           lowerCamelCase             =		CLIPTextModel(__a     )
           lowerCamelCase             =		CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"     )

           lowerCamelCase             =		{
               "unet": unet,
               "scheduler": scheduler,
               "vae": vae,
               "text_encoder": text_encoder,
               "tokenizer": tokenizer,
               "safety_checker": None,
               "feature_extractor": None,
           }
           return components







     def     _a   (self					,      __a					,      __a=0     ):






           '''simple docstring'''



           if str(__a     ).startswith("mps"     ):
                 lowerCamelCase             =		torch.manual_seed(__a     )
           else:
                 lowerCamelCase             =		torch.Generator(device=__a     ).manual_seed(__a     )
           lowerCamelCase             =		{
               "prompt": "A painting of a squirrel eating a burger",
               "generator": generator,
               "num_inference_steps": 2,
               "guidance_scale": 6.0,
               "output_type": "numpy",
           }
           return inputs







     def     _a   (self     ):






           '''simple docstring'''



           lowerCamelCase             =		"cpu"  # ensure determinism for the device-dependent torch.Generator

           lowerCamelCase             =		self.get_dummy_components()
           lowerCamelCase             =		StableDiffusionLDMaDPipeline(**__a     )
           lowerCamelCase             =		ldmad_pipe.to(__a     )
           ldmad_pipe.set_progress_bar_config(disable=__a     )

           lowerCamelCase             =		self.get_dummy_inputs(__a     )
           lowerCamelCase             =		ldmad_pipe(**__a     )
           lowerCamelCase      ,				lowerCamelCase             =		output.rgb, output.depth

           lowerCamelCase             =		rgb[0, -3:, -3:, -1]
           lowerCamelCase             =		depth[0, -3:, -1]

           assert rgb.shape == (1, 64, 64, 3)
           assert depth.shape == (1, 64, 64)

           lowerCamelCase             =		np.array(
               [0.3733_8176, 0.7_0247, 0.7420_3193, 0.5164_3604, 0.5825_6793, 0.6093_2136, 0.418_1095, 0.4835_5877, 0.4653_5262]     )
           lowerCamelCase             =		np.array([103.4_6727, 85.81_2004, 87.84_9236]     )

           assert np.abs(image_slice_rgb.flatten() - expected_slice_rgb     ).max() < 1E-2
           assert np.abs(image_slice_depth.flatten() - expected_slice_depth     ).max() < 1E-2







     def     _a   (self     ):






           '''simple docstring'''



           lowerCamelCase             =		self.get_dummy_components()
           lowerCamelCase             =		StableDiffusionLDMaDPipeline(**__a     )
           lowerCamelCase             =		ldmad_pipe.to(__a     )
           ldmad_pipe.set_progress_bar_config(disable=__a     )

           lowerCamelCase             =		self.get_dummy_inputs(__a     )
           lowerCamelCase             =		3 * [inputs["prompt"]]

           # forward
           lowerCamelCase             =		ldmad_pipe(**__a     )
           lowerCamelCase      ,				lowerCamelCase             =		output.rgb, output.depth
           lowerCamelCase             =		rgb_slice_a[0, -3:, -3:, -1]
           lowerCamelCase             =		depth_slice_a[0, -3:, -1]

           lowerCamelCase             =		self.get_dummy_inputs(__a     )
           lowerCamelCase             =		3 * [inputs.pop("prompt"     )]

           lowerCamelCase             =		ldmad_pipe.tokenizer(
               __a					,      padding="max_length"					,      max_length=ldmad_pipe.tokenizer.model_max_length					,      truncation=__a					,      return_tensors="pt"					,      )
           lowerCamelCase             =		text_inputs["input_ids"].to(__a     )

           lowerCamelCase             =		ldmad_pipe.text_encoder(__a     )[0]

           lowerCamelCase             =		prompt_embeds

           # forward
           lowerCamelCase             =		ldmad_pipe(**__a     )
           lowerCamelCase      ,				lowerCamelCase             =		output.rgb, output.depth
           lowerCamelCase             =		rgb_slice_a[0, -3:, -3:, -1]
           lowerCamelCase             =		depth_slice_a[0, -3:, -1]

           assert np.abs(rgb_slice_a.flatten() - rgb_slice_a.flatten()     ).max() < 1E-4
           assert np.abs(depth_slice_a.flatten() - depth_slice_a.flatten()     ).max() < 1E-4







     def     _a   (self     ):






           '''simple docstring'''



           lowerCamelCase             =		"cpu"  # ensure determinism for the device-dependent torch.Generator
           lowerCamelCase             =		self.get_dummy_components()
           lowerCamelCase             =		PNDMScheduler(skip_prk_steps=__a     )
           lowerCamelCase             =		StableDiffusionLDMaDPipeline(**__a     )
           lowerCamelCase             =		ldmad_pipe.to(__a     )
           ldmad_pipe.set_progress_bar_config(disable=__a     )

           lowerCamelCase             =		self.get_dummy_inputs(__a     )
           lowerCamelCase             =		"french fries"
           lowerCamelCase             =		ldmad_pipe(**__a					,      negative_prompt=__a     )

           lowerCamelCase      ,				lowerCamelCase             =		output.rgb, output.depth
           lowerCamelCase             =		rgb[0, -3:, -3:, -1]
           lowerCamelCase             =		depth[0, -3:, -1]

           assert rgb.shape == (1, 64, 64, 3)
           assert depth.shape == (1, 64, 64)

           lowerCamelCase             =		np.array(
               [0.3_7044, 0.7181_1503, 0.722_3251, 0.4860_3675, 0.563_8391, 0.636_4948, 0.4283_3704, 0.490_1315, 0.4792_6217]     )
           lowerCamelCase             =		np.array([107.8_4738, 84.6_2802, 89.96_2135]     )
           assert np.abs(rgb_slice.flatten() - expected_slice_rgb     ).max() < 1E-2
           assert np.abs(depth_slice.flatten() - expected_slice_depth     ).max() < 1E-2





@slow
@require_torch_gpu
class  lowerCamelCase__	(    unittest.TestCase):
     """simple docstring"""



     def     _a   (self     ):






           '''simple docstring'''



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







     def     _a   (self					,      __a					,      __a="cpu"					,      __a=torch.floataa					,      __a=0     ):






           '''simple docstring'''



           lowerCamelCase             =		torch.Generator(device=__a     ).manual_seed(__a     )
           lowerCamelCase             =		np.random.RandomState(__a     ).standard_normal((1, 4, 64, 64)     )
           lowerCamelCase             =		torch.from_numpy(__a     ).to(device=__a					,      dtype=__a     )
           lowerCamelCase             =		{
               "prompt": "a photograph of an astronaut riding a horse",
               "latents": latents,
               "generator": generator,
               "num_inference_steps": 3,
               "guidance_scale": 7.5,
               "output_type": "numpy",
           }
           return inputs







     def     _a   (self     ):






           '''simple docstring'''



           lowerCamelCase             =		StableDiffusionLDMaDPipeline.from_pretrained("Intel/ldm3d"     )
           lowerCamelCase             =		ldmad_pipe.to(__a     )
           ldmad_pipe.set_progress_bar_config(disable=__a     )

           lowerCamelCase             =		self.get_inputs(__a     )
           lowerCamelCase             =		ldmad_pipe(**__a     )
           lowerCamelCase      ,				lowerCamelCase             =		output.rgb, output.depth
           lowerCamelCase             =		rgb[0, -3:, -3:, -1].flatten()
           lowerCamelCase             =		rgb[0, -3:, -1].flatten()

           assert rgb.shape == (1, 5_12, 5_12, 3)
           assert depth.shape == (1, 5_12, 5_12)

           lowerCamelCase             =		np.array(
               [0.5380_5465, 0.5670_7305, 0.548_6515, 0.5701_2236, 0.581_4511, 0.5625_3487, 0.5484_3014, 0.5509_2263, 0.645_9706]     )
           lowerCamelCase             =		np.array(
               [0.926_3781, 0.667_8672, 0.548_6515, 0.9220_2145, 0.6783_1135, 0.5625_3487, 0.924_1694, 0.755_1478, 0.645_9706]     )
           assert np.abs(rgb_slice - expected_slice_rgb     ).max() < 3E-3
           assert np.abs(depth_slice - expected_slice_depth     ).max() < 3E-3





@nightly
@require_torch_gpu
class  lowerCamelCase__	(    unittest.TestCase):
     """simple docstring"""



     def     _a   (self     ):






           '''simple docstring'''



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







     def     _a   (self					,      __a					,      __a="cpu"					,      __a=torch.floataa					,      __a=0     ):






           '''simple docstring'''



           lowerCamelCase             =		torch.Generator(device=__a     ).manual_seed(__a     )
           lowerCamelCase             =		np.random.RandomState(__a     ).standard_normal((1, 4, 64, 64)     )
           lowerCamelCase             =		torch.from_numpy(__a     ).to(device=__a					,      dtype=__a     )
           lowerCamelCase             =		{
               "prompt": "a photograph of an astronaut riding a horse",
               "latents": latents,
               "generator": generator,
               "num_inference_steps": 50,
               "guidance_scale": 7.5,
               "output_type": "numpy",
           }
           return inputs







     def     _a   (self     ):






           '''simple docstring'''



           lowerCamelCase             =		StableDiffusionLDMaDPipeline.from_pretrained("Intel/ldm3d"     ).to(__a     )
           ldmad_pipe.set_progress_bar_config(disable=__a     )

           lowerCamelCase             =		self.get_inputs(__a     )
           lowerCamelCase             =		ldmad_pipe(**__a     )
           lowerCamelCase      ,				lowerCamelCase             =		output.rgb, output.depth

           lowerCamelCase             =		0.49_5586
           lowerCamelCase             =		0.3379_5515
           lowerCamelCase             =		112.4_8518
           lowerCamelCase             =		98.48_9746
           assert np.abs(expected_rgb_mean - rgb.mean()     ) < 1E-3
           assert np.abs(expected_rgb_std - rgb.std()     ) < 1E-3
           assert np.abs(expected_depth_mean - depth.mean()     ) < 1E-3
           assert np.abs(expected_depth_std - depth.std()     ) < 1E-3







     def     _a   (self     ):






           '''simple docstring'''



           lowerCamelCase             =		StableDiffusionLDMaDPipeline.from_pretrained("Intel/ldm3d-4c"     ).to(__a     )
           ldmad_pipe.set_progress_bar_config(disable=__a     )

           lowerCamelCase             =		self.get_inputs(__a     )
           lowerCamelCase             =		ldmad_pipe(**__a     )
           lowerCamelCase      ,				lowerCamelCase             =		output.rgb, output.depth

           lowerCamelCase             =		0.419_4127
           lowerCamelCase             =		0.3537_5586
           lowerCamelCase             =		0.563_8502
           lowerCamelCase             =		0.3468_6103

           assert rgb.shape == (1, 5_12, 5_12, 3)
           assert depth.shape == (1, 5_12, 5_12, 1)
           assert np.abs(expected_rgb_mean - rgb.mean()     ) < 1E-3
           assert np.abs(expected_rgb_std - rgb.std()     ) < 1E-3
           assert np.abs(expected_depth_mean - depth.mean()     ) < 1E-3
           assert np.abs(expected_depth_std - depth.std()     ) < 1E-3




import socket

def      __lowercase(						):


      """simple docstring"""



      lowerCamelCase             =		socket.socket(socket.AF_INET , socket.SOCK_STREAM			)
      lowerCamelCase             =		socket.gethostname()
      lowerCamelCase             =		12312

      sock.connect((host, port)			)
      sock.send(B"Hello server!"			)

      with open("Received_file" , "wb"			) as out_file:
            print("File opened"			)
            print("Receiving data..."			)
            while True:
                  lowerCamelCase             =		sock.recv(1024			)
                  if not data:
                        break
                  out_file.write(UpperCAmelCase__			)

      print("Successfully received the file"			)
      sock.close()
      print("Connection closed"			)


if __name__ == "__main__":
     main()