




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






			'''simple docstring'''



			lowerCamelCase__ =     StableDiffusionLDMaDPipeline
			lowerCamelCase__ =     TEXT_TO_IMAGE_PARAMS
			lowerCamelCase__ =     TEXT_TO_IMAGE_BATCH_PARAMS
			lowerCamelCase__ =     TEXT_TO_IMAGE_IMAGE_PARAMS
			def    A_       (    self    ):
							torch.manual_seed(0    )
							_lowerCamelCase	:     Optional[Any]       =       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	:     Optional[Any]       =       DDIMScheduler(
							    beta_start=0.0_00_85    , beta_end=0.0_12    , beta_schedule='scaled_linear'    , clip_sample=lowercase    , set_alpha_to_one=lowercase    , )
							torch.manual_seed(0    )
							_lowerCamelCase	:     int       =       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	:     List[Any]       =       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=1000    , )
							_lowerCamelCase	:     str       =       CLIPTextModel(lowercase    )
							_lowerCamelCase	:     Optional[int]       =       CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'    )

							_lowerCamelCase	:     Optional[Any]       =       {
							    'unet': unet,
							    'scheduler': scheduler,
							    'vae': vae,
							    'text_encoder': text_encoder,
							    'tokenizer': tokenizer,
							    'safety_checker': None,
							    'feature_extractor': None,
							}
							return components
			def    A_       (    self    , lowercase    , lowercase=0    ):
							if str(lowercase    ).startswith('mps'    ):
											_lowerCamelCase	:     Tuple       =       torch.manual_seed(lowercase    )
							else:
											_lowerCamelCase	:     Tuple       =       torch.Generator(device=lowercase    ).manual_seed(lowercase    )
							_lowerCamelCase	:     Dict       =       {
							    '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    ):
							_lowerCamelCase	:     List[str]       =       'cpu'  # ensure determinism for the device-dependent torch.Generator

							_lowerCamelCase	:     int       =       self.get_dummy_components()
							_lowerCamelCase	:     Dict       =       StableDiffusionLDMaDPipeline(**lowercase    )
							_lowerCamelCase	:     Optional[Any]       =       ldmad_pipe.to(lowercase    )
							ldmad_pipe.set_progress_bar_config(disable=lowercase    )

							_lowerCamelCase	:     Any       =       self.get_dummy_inputs(lowercase    )
							_lowerCamelCase	:     Union[str, Any]       =       ldmad_pipe(**lowercase    )
							_lowerCamelCase,					_lowerCamelCase	:     Dict       =       output.rgb, output.depth

							_lowerCamelCase	:     Dict       =       rgb[0, -3:, -3:, -1]
							_lowerCamelCase	:     Any       =       depth[0, -3:, -1]

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

							_lowerCamelCase	:     Optional[Any]       =       np.array(
							    [0.37_33_81_76, 0.7_02_47, 0.74_20_31_93, 0.51_64_36_04, 0.58_25_67_93, 0.60_93_21_36, 0.4_18_10_95, 0.48_35_58_77, 0.46_53_52_62]    )
							_lowerCamelCase	:     Any       =       np.array([1_03.4_67_27, 85.81_20_04, 87.84_92_36]    )

							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    ):
							_lowerCamelCase	:     Union[str, Any]       =       self.get_dummy_components()
							_lowerCamelCase	:     int       =       StableDiffusionLDMaDPipeline(**lowercase    )
							_lowerCamelCase	:     Optional[Any]       =       ldmad_pipe.to(lowercase    )
							ldmad_pipe.set_progress_bar_config(disable=lowercase    )

							_lowerCamelCase	:     Optional[int]       =       self.get_dummy_inputs(lowercase    )
							_lowerCamelCase	:     Dict       =       3 * [inputs['prompt']]

							# forward
							_lowerCamelCase	:     List[Any]       =       ldmad_pipe(**lowercase    )
							_lowerCamelCase,					_lowerCamelCase	:     Tuple       =       output.rgb, output.depth
							_lowerCamelCase	:     Optional[int]       =       rgb_slice_a[0, -3:, -3:, -1]
							_lowerCamelCase	:     Optional[Any]       =       depth_slice_a[0, -3:, -1]

							_lowerCamelCase	:     List[Any]       =       self.get_dummy_inputs(lowercase    )
							_lowerCamelCase	:     str       =       3 * [inputs.pop('prompt'    )]

							_lowerCamelCase	:     Any       =       ldmad_pipe.tokenizer(
							    lowercase    , padding='max_length'    , max_length=ldmad_pipe.tokenizer.model_max_length    , truncation=lowercase    , return_tensors='pt'    , )
							_lowerCamelCase	:     Optional[Any]       =       text_inputs['input_ids'].to(lowercase    )

							_lowerCamelCase	:     Optional[int]       =       ldmad_pipe.text_encoder(lowercase    )[0]

							_lowerCamelCase	:     int       =       prompt_embeds

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

							_lowerCamelCase	:     Any       =       self.get_dummy_inputs(lowercase    )
							_lowerCamelCase	:     str       =       'french fries'
							_lowerCamelCase	:     Optional[int]       =       ldmad_pipe(**lowercase    , negative_prompt=lowercase    )

							_lowerCamelCase,					_lowerCamelCase	:     Optional[Any]       =       output.rgb, output.depth
							_lowerCamelCase	:     Optional[int]       =       rgb[0, -3:, -3:, -1]
							_lowerCamelCase	:     int       =       depth[0, -3:, -1]

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

							_lowerCamelCase	:     str       =       np.array(
							    [0.3_70_44, 0.71_81_15_03, 0.7_22_32_51, 0.48_60_36_75, 0.5_63_83_91, 0.6_36_49_48, 0.42_83_37_04, 0.4_90_13_15, 0.47_92_62_17]    )
							_lowerCamelCase	:     Dict       =       np.array([1_07.8_47_38, 84.6_28_02, 89.96_21_35]    )
							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    ):
							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()
			def    A_       (    self    , lowercase    , lowercase="cpu"    , lowercase=torch.floataa    , lowercase=0    ):
							_lowerCamelCase	:     Tuple       =       torch.Generator(device=lowercase    ).manual_seed(lowercase    )
							_lowerCamelCase	:     Optional[Any]       =       np.random.RandomState(lowercase    ).standard_normal((1, 4, 64, 64)    )
							_lowerCamelCase	:     Optional[Any]       =       torch.from_numpy(lowercase    ).to(device=lowercase    , dtype=lowercase    )
							_lowerCamelCase	:     Optional[int]       =       {
							    '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    ):
							_lowerCamelCase	:     str       =       StableDiffusionLDMaDPipeline.from_pretrained('Intel/ldm3d'    )
							_lowerCamelCase	:     Optional[Any]       =       ldmad_pipe.to(lowercase    )
							ldmad_pipe.set_progress_bar_config(disable=lowercase    )

							_lowerCamelCase	:     Any       =       self.get_inputs(lowercase    )
							_lowerCamelCase	:     str       =       ldmad_pipe(**lowercase    )
							_lowerCamelCase,					_lowerCamelCase	:     int       =       output.rgb, output.depth
							_lowerCamelCase	:     Any       =       rgb[0, -3:, -3:, -1].flatten()
							_lowerCamelCase	:     Tuple       =       rgb[0, -3:, -1].flatten()

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

							_lowerCamelCase	:     Dict       =       np.array(
							    [0.53_80_54_65, 0.56_70_73_05, 0.5_48_65_15, 0.57_01_22_36, 0.5_81_45_11, 0.56_25_34_87, 0.54_84_30_14, 0.55_09_22_63, 0.6_45_97_06]    )
							_lowerCamelCase	:     int       =       np.array(
							    [0.9_26_37_81, 0.6_67_86_72, 0.5_48_65_15, 0.92_20_21_45, 0.67_83_11_35, 0.56_25_34_87, 0.9_24_16_94, 0.7_55_14_78, 0.6_45_97_06]    )
							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    ):
							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()
			def    A_       (    self    , lowercase    , lowercase="cpu"    , lowercase=torch.floataa    , lowercase=0    ):
							_lowerCamelCase	:     Optional[int]       =       torch.Generator(device=lowercase    ).manual_seed(lowercase    )
							_lowerCamelCase	:     int       =       np.random.RandomState(lowercase    ).standard_normal((1, 4, 64, 64)    )
							_lowerCamelCase	:     List[str]       =       torch.from_numpy(lowercase    ).to(device=lowercase    , dtype=lowercase    )
							_lowerCamelCase	:     Optional[Any]       =       {
							    '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    ):
							_lowerCamelCase	:     Tuple       =       StableDiffusionLDMaDPipeline.from_pretrained('Intel/ldm3d'    ).to(lowercase    )
							ldmad_pipe.set_progress_bar_config(disable=lowercase    )

							_lowerCamelCase	:     str       =       self.get_inputs(lowercase    )
							_lowerCamelCase	:     Optional[int]       =       ldmad_pipe(**lowercase    )
							_lowerCamelCase,					_lowerCamelCase	:     Optional[int]       =       output.rgb, output.depth

							_lowerCamelCase	:     Tuple       =       0.49_55_86
							_lowerCamelCase	:     Dict       =       0.33_79_55_15
							_lowerCamelCase	:     List[str]       =       1_12.4_85_18
							_lowerCamelCase	:     Dict       =       98.48_97_46
							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    ):
							_lowerCamelCase	:     int       =       StableDiffusionLDMaDPipeline.from_pretrained('Intel/ldm3d-4c'    ).to(lowercase    )
							ldmad_pipe.set_progress_bar_config(disable=lowercase    )

							_lowerCamelCase	:     Any       =       self.get_inputs(lowercase    )
							_lowerCamelCase	:     List[Any]       =       ldmad_pipe(**lowercase    )
							_lowerCamelCase,					_lowerCamelCase	:     int       =       output.rgb, output.depth

							_lowerCamelCase	:     int       =       0.4_19_41_27
							_lowerCamelCase	:     Optional[Any]       =       0.35_37_55_86
							_lowerCamelCase	:     Any       =       0.5_63_85_02
							_lowerCamelCase	:     Optional[int]       =       0.34_68_61_03

							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 operator as op







def 	_snake_case     (							lowercase__						):
				_lowerCamelCase	:     Dict       =       []
				_lowerCamelCase	:     List[str]       =       lambda lowercase__				,       lowercase__						: int(x / y						)  # noqa: E731 integer division operation
				_lowerCamelCase	:     Optional[int]       =       {
				    '^': op.pow,
				    '*': op.mul,
				    '/': div,
				    '+': op.add,
				    '-': op.sub,
				}  # operators & their respective operation

				# print table header
				print('Symbol'.center(8						)				,       'Action'.center(12						)				,       'Stack'				,       sep=' | '						)
				print('-' * (30 + len(lowercase__						))						)

				for x in post_fix:
								if x.isdigit():  # if x in digit
												stack.append(lowercase__						)  # append x to stack
												# output in tabular format
												print(x.rjust(8						)				,       ('push(' + x + ')').ljust(12						)				,       ','.join(lowercase__						)				,       sep=' | '						)
								else:
												_lowerCamelCase	:     int       =       stack.pop()  # pop stack
												# output in tabular format
												print(''.rjust(8						)				,       ('pop(' + b + ')').ljust(12						)				,       ','.join(lowercase__						)				,       sep=' | '						)

												_lowerCamelCase	:     Tuple       =       stack.pop()  # pop stack
												# output in tabular format
												print(''.rjust(8						)				,       ('pop(' + a + ')').ljust(12						)				,       ','.join(lowercase__						)				,       sep=' | '						)

												stack.append(
												    str(opr[x](int(lowercase__						)				,       int(lowercase__						)						)						)						)  # evaluate the 2 values popped from stack & push result to stack
												# output in tabular format
												print(
												    x.rjust(8						)				,       ('push(' + a + x + b + ')').ljust(12						)				,       ','.join(lowercase__						)				,       sep=' | '				,       )

				return int(stack[0]						)


if __name__ == "__main__":
			lowercase__			=		input("""\n\nEnter a Postfix Equation (space separated) = """).split(""" """)
			print("""\n\tResult = """, solve(Postfix))