






"""simple docstring"""






import gc
import unittest

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

from diffusers import HeunDiscreteScheduler, PriorTransformer, ShapEPipeline
from diffusers.pipelines.shap_e import ShapERenderer
from diffusers.utils import load_numpy, slow
from diffusers.utils.testing_utils import require_torch_gpu, torch_device

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference




class 							lowerCAmelCase__       (    UpperCAmelCase_       ,	unittest.TestCase				):






      '''simple docstring'''

      __UpperCamelCase							=						ShapEPipeline
      __UpperCamelCase							=						['prompt']
      __UpperCamelCase							=						['prompt']
      __UpperCamelCase							=						[
          'num_images_per_prompt',
          'num_inference_steps',
          'generator',
          'latents',
          'guidance_scale',
          'frame_size',
          'output_type',
          'return_dict',
      ]
      __UpperCamelCase							=						False
      @property
      def _SCREAMING_SNAKE_CASE				(		self  :						Any):




          '''simple docstring'''


          return 32
      @property
      def _SCREAMING_SNAKE_CASE				(		self  :						str):




          '''simple docstring'''


          return 32
      @property
      def _SCREAMING_SNAKE_CASE				(		self  :						Union[str, Any]):




          '''simple docstring'''


          return self.time_input_dim * 4
      @property
      def _SCREAMING_SNAKE_CASE				(		self  :						str):




          '''simple docstring'''


          return 8
      @property
      def _SCREAMING_SNAKE_CASE				(		self  :						Optional[Any]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						str							=	CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''')
          return tokenizer
      @property
      def _SCREAMING_SNAKE_CASE				(		self  :						List[str]):




          '''simple docstring'''


          torch.manual_seed(0)
          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	CLIPTextConfig(
              bos_token_id=0		,			eos_token_id=2		,			hidden_size=self.text_embedder_hidden_size		,			projection_dim=self.text_embedder_hidden_size		,			intermediate_size=37		,			layer_norm_eps=1e-05		,			num_attention_heads=4		,			num_hidden_layers=5		,			pad_token_id=1		,			vocab_size=1000		,			)
          return CLIPTextModelWithProjection(_lowercase)
      @property
      def _SCREAMING_SNAKE_CASE				(		self  :						str):




          '''simple docstring'''


          torch.manual_seed(0)

          SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	{
              'num_attention_heads': 2,
              'attention_head_dim': 16,
              'embedding_dim': self.time_input_dim,
              'num_embeddings': 32,
              'embedding_proj_dim': self.text_embedder_hidden_size,
              'time_embed_dim': self.time_embed_dim,
              'num_layers': 1,
              'clip_embed_dim': self.time_input_dim * 2,
              'additional_embeddings': 0,
              'time_embed_act_fn': 'gelu',
              'norm_in_type': 'layer',
              'encoder_hid_proj_type': None,
              'added_emb_type': None,
          }

          SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	PriorTransformer(**_lowercase)
          return model
      @property
      def _SCREAMING_SNAKE_CASE				(		self  :						Optional[int]):




          '''simple docstring'''


          torch.manual_seed(0)

          SCREAMING_SNAKE_CASE_   :						List[str]							=	{
              'param_shapes': (
                  (self.renderer_dim, 93),
                  (self.renderer_dim, 8),
                  (self.renderer_dim, 8),
                  (self.renderer_dim, 8),
              ),
              'd_latent': self.time_input_dim,
              'd_hidden': self.renderer_dim,
              'n_output': 12,
              'background': (
                  0.1,
                  0.1,
                  0.1,
              ),
          }
          SCREAMING_SNAKE_CASE_   :						Dict							=	ShapERenderer(**_lowercase)
          return model
      def _SCREAMING_SNAKE_CASE				(		self  :						Dict):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	self.dummy_prior
          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	self.dummy_text_encoder
          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	self.dummy_tokenizer
          SCREAMING_SNAKE_CASE_   :						List[Any]							=	self.dummy_renderer

          SCREAMING_SNAKE_CASE_   :						Any							=	HeunDiscreteScheduler(
              beta_schedule='''exp'''		,			num_train_timesteps=1024		,			prediction_type='''sample'''		,			use_karras_sigmas=_lowercase		,			clip_sample=_lowercase		,			clip_sample_range=1.0		,			)
          SCREAMING_SNAKE_CASE_   :						str							=	{
              'prior': prior,
              'text_encoder': text_encoder,
              'tokenizer': tokenizer,
              'renderer': renderer,
              'scheduler': scheduler,
          }

          return components
      def _SCREAMING_SNAKE_CASE				(		self  :						Tuple		,			lowercase_  :						Union[str, Any]		,			lowercase_  :						Dict=0):




          '''simple docstring'''


          if str(_lowercase).startswith('''mps'''):
              SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	torch.manual_seed(_lowercase)
          else:
              SCREAMING_SNAKE_CASE_   :						int							=	torch.Generator(device=_lowercase).manual_seed(_lowercase)
          SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	{
              'prompt': 'horse',
              'generator': generator,
              'num_inference_steps': 1,
              'frame_size': 32,
              'output_type': 'np',
          }
          return inputs
      def _SCREAMING_SNAKE_CASE				(		self  :						List[Any]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	'cpu'

          SCREAMING_SNAKE_CASE_   :						List[Any]							=	self.get_dummy_components()

          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	self.pipeline_class(**_lowercase)
          SCREAMING_SNAKE_CASE_   :						List[str]							=	pipe.to(_lowercase)

          pipe.set_progress_bar_config(disable=_lowercase)

          SCREAMING_SNAKE_CASE_   :						Dict							=	pipe(**self.get_dummy_inputs(_lowercase))
          SCREAMING_SNAKE_CASE_   :						Dict							=	output.images[0]
          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	image[0, -3:, -3:, -1]

          assert image.shape == (20, 32, 32, 3)

          SCREAMING_SNAKE_CASE_   :						int							=	np.array(
              [
                  0.00_03_92_16,
                  0.00_03_92_16,
                  0.00_03_92_16,
                  0.00_03_92_16,
                  0.00_03_92_16,
                  0.00_03_92_16,
                  0.00_03_92_16,
                  0.00_03_92_16,
                  0.00_03_92_16,
              ])

          assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2
      def _SCREAMING_SNAKE_CASE				(		self  :						Tuple):




          '''simple docstring'''


          self._test_inference_batch_consistent(batch_sizes=[1, 2])
      def _SCREAMING_SNAKE_CASE				(		self  :						List[Any]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						str							=	torch_device == 'cpu'
          SCREAMING_SNAKE_CASE_   :						str							=	True

          self._test_inference_batch_single_identical(
              batch_size=2		,			test_max_difference=_lowercase		,			relax_max_difference=_lowercase		,			)



      def _SCREAMING_SNAKE_CASE				(		self  :						Optional[int]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						int							=	self.get_dummy_components()
          SCREAMING_SNAKE_CASE_   :						Any							=	self.pipeline_class(**_lowercase)
          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	pipe.to(_lowercase)
          pipe.set_progress_bar_config(disable=_lowercase)

          SCREAMING_SNAKE_CASE_   :						List[Any]							=	1
          SCREAMING_SNAKE_CASE_   :						int							=	2

          SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	self.get_dummy_inputs(_lowercase)

          for key in inputs.keys():
              if key in self.batch_params:
                  SCREAMING_SNAKE_CASE_   :						List[Any]							=	batch_size * [inputs[key]]

          SCREAMING_SNAKE_CASE_   :						Tuple							=	pipe(**_lowercase		,			num_images_per_prompt=_lowercase)[0]

          assert images.shape[0] == batch_size * num_images_per_prompt




@slow
@require_torch_gpu
class 							lowerCAmelCase__       (    unittest.TestCase				):






      '''simple docstring'''

      def _SCREAMING_SNAKE_CASE				(		self  :						Any):




          '''simple docstring'''


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



      def _SCREAMING_SNAKE_CASE				(		self  :						Any):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						str							=	load_numpy(
              '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
              '''/shap_e/test_shap_e_np_out.npy''')
          SCREAMING_SNAKE_CASE_   :						int							=	ShapEPipeline.from_pretrained('''openai/shap-e''')
          SCREAMING_SNAKE_CASE_   :						str							=	pipe.to(_lowercase)
          pipe.set_progress_bar_config(disable=_lowercase)

          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	torch.Generator(device=_lowercase).manual_seed(0)

          SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	pipe(
              '''a shark'''		,			generator=_lowercase		,			guidance_scale=15.0		,			num_inference_steps=64		,			frame_size=64		,			output_type='''np'''		,			).images[0]

          assert images.shape == (20, 64, 64, 3)

          assert_mean_pixel_difference(_lowercase		,			_lowercase)










"""simple docstring"""






from __future__ import annotations

import requests



def       _A    (__a							)				-> dict:
    """simple docstring"""






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



def       _A    (__a = 10							)				-> list[dict]:
    """simple docstring"""






    SCREAMING_SNAKE_CASE_   :						Any							=	'''https://hacker-news.firebaseio.com/v0/topstories.json?print=pretty'''
    SCREAMING_SNAKE_CASE_   :						Dict							=	requests.get(__a							).json()[:max_stories]
    return [get_hackernews_story(__a							) for story_id in story_ids]



def       _A    (__a = 10							)				-> str:
    """simple docstring"""






    SCREAMING_SNAKE_CASE_   :						Tuple							=	hackernews_top_stories(__a							)
    return "\n".join('''* [{title}]({url})'''.format(**__a							) for story in stories							)


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


