




"""simple docstring"""

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     lowercase_	(					unittest.TestCase							):



 '''simple docstring'''
 UpperCAmelCase   :					Optional[int]				  =     StableDiffusionLDMaDPipeline
 UpperCAmelCase   :					List[Any]				  =     TEXT_TO_IMAGE_PARAMS
 UpperCAmelCase   :					Tuple				  =     TEXT_TO_IMAGE_BATCH_PARAMS
 UpperCAmelCase   :					Optional[Any]				  =     TEXT_TO_IMAGE_IMAGE_PARAMS

 def       lowerCAmelCase_							(			self	:	Optional[Any]		):
       torch.manual_seed(0		)
       _A        =       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   ,							)
       _A        =       DDIMScheduler(
           beta_start=0.0_0085   ,							beta_end=0.012   ,							beta_schedule='scaled_linear'   ,							clip_sample=_UpperCAmelCase   ,							set_alpha_to_one=_UpperCAmelCase   ,							)
       torch.manual_seed(0		)
       _A        =       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		)
       _A        =       CLIPTextConfig(
           bos_token_id=0   ,							eos_token_id=2   ,							hidden_size=32   ,							intermediate_size=37   ,							layer_norm_eps=1E-0_5   ,							num_attention_heads=4   ,							num_hidden_layers=5   ,							pad_token_id=1   ,							vocab_size=1_000   ,							)
       _A        =       CLIPTextModel(_UpperCAmelCase		)
       _A        =       CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'		)

       _A        =       {
           'unet': unet,
           'scheduler': scheduler,
           'vae': vae,
           'text_encoder': text_encoder,
           'tokenizer': tokenizer,
           'safety_checker': None,
           'feature_extractor': None,
       }
       return components

 def       lowerCAmelCase_							(			self	:	Optional[int]   ,							_UpperCAmelCase	:	List[str]   ,							_UpperCAmelCase	:	int=0		):
       if str(_UpperCAmelCase		).startswith('mps'		):
             _A        =       torch.manual_seed(_UpperCAmelCase		)
       else:
             _A        =       torch.Generator(device=_UpperCAmelCase		).manual_seed(_UpperCAmelCase		)
       _A        =       {
           '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       lowerCAmelCase_							(			self	:	int		):
       _A        =       'cpu'  # ensure determinism for the device-dependent torch.Generator

       _A        =       self.get_dummy_components()
       _A        =       StableDiffusionLDMaDPipeline(**_UpperCAmelCase		)
       _A        =       ldmad_pipe.to(_UpperCAmelCase		)
       ldmad_pipe.set_progress_bar_config(disable=_UpperCAmelCase		)

       _A        =       self.get_dummy_inputs(_UpperCAmelCase		)
       _A        =       ldmad_pipe(**_UpperCAmelCase		)
       _A       ,   _A        =       output.rgb, output.depth

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

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

       _A        =       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]		)
       _A        =       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       lowerCAmelCase_							(			self	:	Optional[int]		):
       _A        =       self.get_dummy_components()
       _A        =       StableDiffusionLDMaDPipeline(**_UpperCAmelCase		)
       _A        =       ldmad_pipe.to(_UpperCAmelCase		)
       ldmad_pipe.set_progress_bar_config(disable=_UpperCAmelCase		)

       _A        =       self.get_dummy_inputs(_UpperCAmelCase		)
       _A        =       3 * [inputs['prompt']]

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

       _A        =       self.get_dummy_inputs(_UpperCAmelCase		)
       _A        =       3 * [inputs.pop('prompt'		)]

       _A        =       ldmad_pipe.tokenizer(
           _UpperCAmelCase   ,							padding='max_length'   ,							max_length=ldmad_pipe.tokenizer.model_max_length   ,							truncation=_UpperCAmelCase   ,							return_tensors='pt'   ,							)
       _A        =       text_inputs['input_ids'].to(_UpperCAmelCase		)

       _A        =       ldmad_pipe.text_encoder(_UpperCAmelCase		)[0]

       _A        =       prompt_embeds

       # forward
       _A        =       ldmad_pipe(**_UpperCAmelCase		)
       _A       ,   _A        =       output.rgb, output.depth
       _A        =       rgb_slice_a[0, -3:, -3:, -1]
       _A        =       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       lowerCAmelCase_							(			self	:	Dict		):
       _A        =       'cpu'  # ensure determinism for the device-dependent torch.Generator
       _A        =       self.get_dummy_components()
       _A        =       PNDMScheduler(skip_prk_steps=_UpperCAmelCase		)
       _A        =       StableDiffusionLDMaDPipeline(**_UpperCAmelCase		)
       _A        =       ldmad_pipe.to(_UpperCAmelCase		)
       ldmad_pipe.set_progress_bar_config(disable=_UpperCAmelCase		)

       _A        =       self.get_dummy_inputs(_UpperCAmelCase		)
       _A        =       'french fries'
       _A        =       ldmad_pipe(**_UpperCAmelCase   ,							negative_prompt=_UpperCAmelCase		)

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

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

       _A        =       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]		)
       _A        =       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     lowercase_	(					unittest.TestCase							):



 '''simple docstring'''

 def       lowerCAmelCase_							(			self	:	Dict		):
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()

 def       lowerCAmelCase_							(			self	:	List[Any]   ,							_UpperCAmelCase	:	Union[str, Any]   ,							_UpperCAmelCase	:	str="cpu"   ,							_UpperCAmelCase	:	Any=torch.floataa   ,							_UpperCAmelCase	:	str=0		):
       _A        =       torch.Generator(device=_UpperCAmelCase		).manual_seed(_UpperCAmelCase		)
       _A        =       np.random.RandomState(_UpperCAmelCase		).standard_normal((1, 4, 64, 64)		)
       _A        =       torch.from_numpy(_UpperCAmelCase		).to(device=_UpperCAmelCase   ,							dtype=_UpperCAmelCase		)
       _A        =       {
           '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       lowerCAmelCase_							(			self	:	Optional[int]		):
       _A        =       StableDiffusionLDMaDPipeline.from_pretrained('Intel/ldm3d'		)
       _A        =       ldmad_pipe.to(_UpperCAmelCase		)
       ldmad_pipe.set_progress_bar_config(disable=_UpperCAmelCase		)

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

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

       _A        =       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]		)
       _A        =       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     lowercase_	(					unittest.TestCase							):



 '''simple docstring'''

 def       lowerCAmelCase_							(			self	:	str		):
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()

 def       lowerCAmelCase_							(			self	:	Dict   ,							_UpperCAmelCase	:	List[str]   ,							_UpperCAmelCase	:	Union[str, Any]="cpu"   ,							_UpperCAmelCase	:	Dict=torch.floataa   ,							_UpperCAmelCase	:	List[str]=0		):
       _A        =       torch.Generator(device=_UpperCAmelCase		).manual_seed(_UpperCAmelCase		)
       _A        =       np.random.RandomState(_UpperCAmelCase		).standard_normal((1, 4, 64, 64)		)
       _A        =       torch.from_numpy(_UpperCAmelCase		).to(device=_UpperCAmelCase   ,							dtype=_UpperCAmelCase		)
       _A        =       {
           '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       lowerCAmelCase_							(			self	:	List[Any]		):
       _A        =       StableDiffusionLDMaDPipeline.from_pretrained('Intel/ldm3d'		).to(_UpperCAmelCase		)
       ldmad_pipe.set_progress_bar_config(disable=_UpperCAmelCase		)

       _A        =       self.get_inputs(_UpperCAmelCase		)
       _A        =       ldmad_pipe(**_UpperCAmelCase		)
       _A       ,   _A        =       output.rgb, output.depth

       _A        =       0.49_5586
       _A        =       0.3379_5515
       _A        =       112.4_8518
       _A        =       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       lowerCAmelCase_							(			self	:	List[Any]		):
       _A        =       StableDiffusionLDMaDPipeline.from_pretrained('Intel/ldm3d-4c'		).to(_UpperCAmelCase		)
       ldmad_pipe.set_progress_bar_config(disable=_UpperCAmelCase		)

       _A        =       self.get_inputs(_UpperCAmelCase		)
       _A        =       ldmad_pipe(**_UpperCAmelCase		)
       _A       ,   _A        =       output.rgb, output.depth

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

       assert rgb.shape == (1, 512, 512, 3)
       assert depth.shape == (1, 512, 512, 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







"""simple docstring"""

import inspect
import os
import unittest
from pathlib import Path

import torch

import accelerate
from accelerate.test_utils import execute_subprocess_async
from accelerate.test_utils.testing import run_command





class     lowercase_	(					unittest.TestCase							):



 '''simple docstring'''
 UpperCAmelCase   :					str				  =     inspect.getfile(accelerate.test_utils							)
 UpperCAmelCase   :					Optional[Any]				  =     os.path.sep.join(mod_file.split(os.path.sep							)[:-1] + ['''scripts''', '''test_cli.py''']							)

 UpperCAmelCase   :					List[Any]				  =     ['''accelerate''', '''launch''']
 UpperCAmelCase   :					Dict				  =     Path.home() / '''.cache/huggingface/accelerate'''
 UpperCAmelCase   :					Union[str, Any]				  =     '''default_config.yaml'''
 UpperCAmelCase   :					Union[str, Any]				  =     config_folder / config_file
 UpperCAmelCase   :					Union[str, Any]				  =     config_folder / '''_default_config.yaml'''

 UpperCAmelCase   :					List[Any]				  =     Path('''tests/test_configs'''							)

 @classmethod
 def       lowerCAmelCase_							(			cls	:	List[Any]		):
       if cls.config_path.is_file():
             cls.config_path.rename(cls.changed_path		)

 @classmethod
 def       lowerCAmelCase_							(			cls	:	Tuple		):
       if cls.changed_path.is_file():
             cls.changed_path.rename(cls.config_path		)

 def       lowerCAmelCase_							(			self	:	List[Any]		):
       _A        =       self.base_cmd
       if torch.cuda.is_available() and (torch.cuda.device_count() > 1):
             cmd += ["--multi_gpu"]
       execute_subprocess_async(cmd + [self.test_file_path]   ,							env=os.environ.copy()		)

 def       lowerCAmelCase_							(			self	:	Optional[int]		):
       for config in sorted(self.test_config_path.glob('**/*.yaml'		)		):
             with self.subTest(config_file=_UpperCAmelCase		):
                   execute_subprocess_async(
                       self.base_cmd + ['--config_file', str(_UpperCAmelCase		), self.test_file_path]   ,							env=os.environ.copy()		)



 def       lowerCAmelCase_							(			self	:	Any		):
       execute_subprocess_async(['accelerate', 'test']   ,							env=os.environ.copy()		)





class     lowercase_	(					unittest.TestCase							):



 '''simple docstring'''
 UpperCAmelCase   :					Dict				  =     '''test-tpu'''
 UpperCAmelCase   :					Optional[int]				  =     '''us-central1-a'''
 UpperCAmelCase   :					List[str]				  =     '''ls'''
 UpperCAmelCase   :					str				  =     ['''accelerate''', '''tpu-config''']
 UpperCAmelCase   :					Optional[Any]				  =     '''cd /usr/share'''
 UpperCAmelCase   :					Optional[Any]				  =     '''tests/test_samples/test_command_file.sh'''
 UpperCAmelCase   :					str				  =     '''Running gcloud compute tpus tpu-vm ssh'''

 def       lowerCAmelCase_							(			self	:	Any		):
       _A        =       run_command(
           self.cmd
           + ['--command', self.command, '--tpu_zone', self.tpu_zone, '--tpu_name', self.tpu_name, '--debug']   ,							return_stdout=_UpperCAmelCase   ,							)
       self.assertIn(
           F'''{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; ls --worker all'''   ,							_UpperCAmelCase   ,							)

 def       lowerCAmelCase_							(			self	:	Dict		):
       _A        =       run_command(
           self.cmd
           + [
               '--config_file',
               'tests/test_configs/0_12_0.yaml',
               '--command',
               self.command,
               '--tpu_zone',
               self.tpu_zone,
               '--tpu_name',
               self.tpu_name,
               '--debug',
           ]   ,							return_stdout=_UpperCAmelCase   ,							)
       self.assertIn(
           F'''{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; ls --worker all'''   ,							_UpperCAmelCase   ,							)

 def       lowerCAmelCase_							(			self	:	Optional[int]		):
       _A        =       run_command(
           self.cmd + ['--config_file', 'tests/test_configs/latest.yaml', '--debug']   ,							return_stdout=_UpperCAmelCase		)
       self.assertIn(
           F'''{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; echo "hello world"; echo "this is a second command" --worker all'''   ,							_UpperCAmelCase   ,							)

 def       lowerCAmelCase_							(			self	:	str		):
       _A        =       run_command(
           self.cmd + ['--config_file', 'tests/test_configs/latest.yaml', '--command', self.command, '--debug']   ,							return_stdout=_UpperCAmelCase   ,							)
       self.assertIn(
           F'''{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; ls --worker all'''   ,							_UpperCAmelCase   ,							)

 def       lowerCAmelCase_							(			self	:	List[str]		):
       _A        =       run_command(
           self.cmd
           + [
               '--config_file',
               'tests/test_configs/latest.yaml',
               '--command',
               self.command,
               '--command',
               'echo "Hello World"',
               '--debug',
           ]   ,							return_stdout=_UpperCAmelCase   ,							)
       self.assertIn(
           F'''{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; ls; echo "Hello World" --worker all'''   ,							_UpperCAmelCase   ,							)

 def       lowerCAmelCase_							(			self	:	str		):
       _A        =       run_command(
           self.cmd
           + ['--config_file', 'tests/test_configs/latest.yaml', '--command_file', self.command_file, '--debug']   ,							return_stdout=_UpperCAmelCase   ,							)
       self.assertIn(
           F'''{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; echo "hello world"; echo "this is a second command" --worker all'''   ,							_UpperCAmelCase   ,							)

 def       lowerCAmelCase_							(			self	:	List[Any]		):
       _A        =       run_command(
           self.cmd
           + [
               '--config_file',
               'tests/test_configs/0_12_0.yaml',
               '--command_file',
               self.command_file,
               '--tpu_zone',
               self.tpu_zone,
               '--tpu_name',
               self.tpu_name,
               '--debug',
           ]   ,							return_stdout=_UpperCAmelCase   ,							)
       self.assertIn(
           F'''{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; echo "hello world"; echo "this is a second command" --worker all'''   ,							_UpperCAmelCase   ,							)

 def       lowerCAmelCase_							(			self	:	int		):
       _A        =       run_command(
           self.cmd + ['--config_file', 'tests/test_configs/latest.yaml', '--install_accelerate', '--debug']   ,							return_stdout=_UpperCAmelCase   ,							)
       self.assertIn(
           F'''{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; pip install accelerate -U; echo "hello world"; echo "this is a second command" --worker all'''   ,							_UpperCAmelCase   ,							)



 def       lowerCAmelCase_							(			self	:	Optional[int]		):
       _A        =       run_command(
           self.cmd
           + [
               '--config_file',
               'tests/test_configs/latest.yaml',
               '--install_accelerate',
               '--accelerate_version',
               '12.0.0',
               '--debug',
           ]   ,							return_stdout=_UpperCAmelCase   ,							)
       self.assertIn(
           F'''{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; pip install accelerate==12.0.0; echo "hello world"; echo "this is a second command" --worker all'''   ,							_UpperCAmelCase   ,							)

