


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

    """simple docstring"""







    lowerCAmelCase 		= StableDiffusionLDMaDPipeline
    lowerCAmelCase 		= TEXT_TO_IMAGE_PARAMS
    lowerCAmelCase 		= TEXT_TO_IMAGE_BATCH_PARAMS
    lowerCAmelCase 		= TEXT_TO_IMAGE_IMAGE_PARAMS

    def      _UpperCAmelCase					(						self   )	->				str:
     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_00_85				,   beta_end=0.0_12				,   beta_schedule="""scaled_linear"""				,   clip_sample=a__				,   set_alpha_to_one=a__				,   )
     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-05				,   num_attention_heads=4				,   num_hidden_layers=5				,   pad_token_id=1				,   vocab_size=1000				,   )
     A								=				CLIPTextModel(a__   )
     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      _UpperCAmelCase					(						self				,   a__				,   a__=0   )	->				Dict:
     if str(a__   ).startswith("""mps"""   ):
      A								=				torch.manual_seed(a__   )
     else:
      A								=				torch.Generator(device=a__   ).manual_seed(a__   )
     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      _UpperCAmelCase					(						self   )	->				Dict:
     A								=				"""cpu"""  # ensure determinism for the device-dependent torch.Generator

     A								=				self.get_dummy_components()
     A								=				StableDiffusionLDMaDPipeline(**a__   )
     A								=				ldmad_pipe.to(a__   )
     ldmad_pipe.set_progress_bar_config(disable=a__   )

     A								=				self.get_dummy_inputs(a__   )
     A								=				ldmad_pipe(**a__   )
     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.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]   )
     A								=				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      _UpperCAmelCase					(						self   )	->				Dict:
     A								=				self.get_dummy_components()
     A								=				StableDiffusionLDMaDPipeline(**a__   )
     A								=				ldmad_pipe.to(a__   )
     ldmad_pipe.set_progress_bar_config(disable=a__   )

     A								=				self.get_dummy_inputs(a__   )
     A								=				3 * [inputs["""prompt"""]]

     # forward
     A								=				ldmad_pipe(**a__   )
     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(a__   )
     A								=				3 * [inputs.pop("""prompt"""   )]

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

     A								=				ldmad_pipe.text_encoder(a__   )[0]

     A								=				prompt_embeds

     # forward
     A								=				ldmad_pipe(**a__   )
     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      _UpperCAmelCase					(						self   )	->				int:
     A								=				"""cpu"""  # ensure determinism for the device-dependent torch.Generator
     A								=				self.get_dummy_components()
     A								=				PNDMScheduler(skip_prk_steps=a__   )
     A								=				StableDiffusionLDMaDPipeline(**a__   )
     A								=				ldmad_pipe.to(a__   )
     ldmad_pipe.set_progress_bar_config(disable=a__   )

     A								=				self.get_dummy_inputs(a__   )
     A								=				"""french fries"""
     A								=				ldmad_pipe(**a__				,   negative_prompt=a__   )

     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_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]   )
     A								=				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       _UpperCamelCase    (					unittest.TestCase				):

    """simple docstring"""







    def      _UpperCAmelCase					(						self   )	->				Optional[Any]:
     super().tearDown()
     gc.collect()
     torch.cuda.empty_cache()

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

     A								=				self.get_inputs(a__   )
     A								=				ldmad_pipe(**a__   )
     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.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]   )
     A								=				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       _UpperCamelCase    (					unittest.TestCase				):

    """simple docstring"""







    def      _UpperCAmelCase					(						self   )	->				int:
     super().tearDown()
     gc.collect()
     torch.cuda.empty_cache()

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

     A								=				self.get_inputs(a__   )
     A								=				ldmad_pipe(**a__   )
     A					,			A								=				output.rgb, output.depth

     A								=				0.49_55_86
     A								=				0.33_79_55_15
     A								=				1_12.4_85_18
     A								=				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      _UpperCAmelCase					(						self   )	->				str:
     A								=				StableDiffusionLDMaDPipeline.from_pretrained("""Intel/ldm3d-4c"""   ).to(a__   )
     ldmad_pipe.set_progress_bar_config(disable=a__   )

     A								=				self.get_inputs(a__   )
     A								=				ldmad_pipe(**a__   )
     A					,			A								=				output.rgb, output.depth

     A								=				0.4_19_41_27
     A								=				0.35_37_55_86
     A								=				0.5_63_85_02
     A								=				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







from __future__ import annotations

import requests





def   _lowerCAmelCase				(   UpperCamelCase__:     str						) ->   dict:





	"""simple docstring"""







	A								=				f'https://hacker-news.firebaseio.com/v0/item/{story_id}.json?print=pretty'
	return requests.get(UpperCamelCase__						).json()





def   _lowerCAmelCase				(   UpperCamelCase__:     int = 10						) ->   list[dict]:





	"""simple docstring"""







	A								=				"""https://hacker-news.firebaseio.com/v0/topstories.json?print=pretty"""
	A								=				requests.get(UpperCamelCase__						).json()[:max_stories]
	return [get_hackernews_story(UpperCamelCase__						) for story_id in story_ids]





def   _lowerCAmelCase				(   UpperCamelCase__:     int = 10						) ->   str:





	"""simple docstring"""







	A								=				hackernews_top_stories(UpperCamelCase__						)
	return "\n".join("""* [{title}]({url})""".format(**UpperCamelCase__						) for story in stories						)


if __name__ == "__main__":
				print(hackernews_top_stories_as_markdown())



