
"""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 A_	(lowercase__				,unittest.TestCase      ):




  '''simple docstring'''
  SCREAMING_SNAKE_CASE__			:						Any       =		ShapEPipeline
  SCREAMING_SNAKE_CASE__			:						Any       =		["""prompt"""]
  SCREAMING_SNAKE_CASE__			:						str       =		["""prompt"""]
  SCREAMING_SNAKE_CASE__			:						List[str]       =		[
      """num_images_per_prompt""",
      """num_inference_steps""",
      """generator""",
      """latents""",
      """guidance_scale""",
      """frame_size""",
      """output_type""",
      """return_dict""",
  ]
  SCREAMING_SNAKE_CASE__			:						int       =		False







  @property
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     return 32







  @property
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     return 32







  @property
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     return self.time_input_dim * 4







  @property
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     return 8







  @property
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Optional[int]			     =    CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"  )
     return tokenizer







  @property
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     torch.manual_seed(0  )
     UpperCAmelCase_					:					List[Any]			     =    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-0_5				,   num_attention_heads=4				,   num_hidden_layers=5				,   pad_token_id=1				,   vocab_size=1000				,   )
     return CLIPTextModelWithProjection(lowercase_  )







  @property
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     torch.manual_seed(0  )

     UpperCAmelCase_					:					List[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,
     }

     UpperCAmelCase_					:					str			     =    PriorTransformer(**lowercase_  )
     return model







  @property
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     torch.manual_seed(0  )

     UpperCAmelCase_					:					Any			     =    {
         "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,
         ),
     }
     UpperCAmelCase_					:					Dict			     =    ShapERenderer(**lowercase_  )
     return model







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Any			     =    self.dummy_prior
     UpperCAmelCase_					:					Optional[int]			     =    self.dummy_text_encoder
     UpperCAmelCase_					:					Optional[Any]			     =    self.dummy_tokenizer
     UpperCAmelCase_					:					List[Any]			     =    self.dummy_renderer

     UpperCAmelCase_					:					List[Any]			     =    HeunDiscreteScheduler(
         beta_schedule="exp"				,   num_train_timesteps=1024				,   prediction_type="sample"				,   use_karras_sigmas=lowercase_				,   clip_sample=lowercase_				,   clip_sample_range=1.0				,   )
     UpperCAmelCase_					:					Any			     =    {
         "prior": prior,
         "text_encoder": text_encoder,
         "tokenizer": tokenizer,
         "renderer": renderer,
         "scheduler": scheduler,
     }

     return components







  def        UpperCamelCase__					(		self				,   lowercase_				,   lowercase_=0  ):

     """simple docstring"""
     if str(lowercase_  ).startswith("mps"  ):
        UpperCAmelCase_					:					Optional[int]			     =    torch.manual_seed(lowercase_  )
     else:
        UpperCAmelCase_					:					str			     =    torch.Generator(device=lowercase_  ).manual_seed(lowercase_  )
     UpperCAmelCase_					:					List[Any]			     =    {
         "prompt": "horse",
         "generator": generator,
         "num_inference_steps": 1,
         "frame_size": 32,
         "output_type": "np",
     }
     return inputs







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Optional[Any]			     =    "cpu"

     UpperCAmelCase_					:					List[str]			     =    self.get_dummy_components()

     UpperCAmelCase_					:					List[Any]			     =    self.pipeline_class(**lowercase_  )
     UpperCAmelCase_					:					Union[str, Any]			     =    pipe.to(lowercase_  )

     pipe.set_progress_bar_config(disable=lowercase_  )

     UpperCAmelCase_					:					Union[str, Any]			     =    pipe(**self.get_dummy_inputs(lowercase_  )  )
     UpperCAmelCase_					:					Any			     =    output.images[0]
     UpperCAmelCase_					:					Any			     =    image[0, -3:, -3:, -1]

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

     UpperCAmelCase_					:					Tuple			     =    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        UpperCamelCase__					(		self  ):

     """simple docstring"""
     # NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
     self._test_inference_batch_consistent(batch_sizes=[1, 2]  )







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Optional[int]			     =    torch_device == "cpu"
     UpperCAmelCase_					:					List[str]			     =    True

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







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					List[str]			     =    self.get_dummy_components()
     UpperCAmelCase_					:					List[Any]			     =    self.pipeline_class(**lowercase_  )
     UpperCAmelCase_					:					Any			     =    pipe.to(lowercase_  )
     pipe.set_progress_bar_config(disable=lowercase_  )

     UpperCAmelCase_					:					Optional[int]			     =    1
     UpperCAmelCase_					:					Tuple			     =    2

     UpperCAmelCase_					:					Tuple			     =    self.get_dummy_inputs(lowercase_  )

     for key in inputs.keys():
        if key in self.batch_params:
           UpperCAmelCase_					:					Tuple			     =    batch_size * [inputs[key]]

     UpperCAmelCase_					:					Optional[Any]			     =    pipe(**lowercase_				,   num_images_per_prompt=lowercase_  )[0]

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




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




  '''simple docstring'''







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     # clean up the VRAM after each test
     super().tearDown()
     gc.collect()
     torch.cuda.empty_cache()







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					int			     =    load_numpy(
         "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
         "/shap_e/test_shap_e_np_out.npy"  )
     UpperCAmelCase_					:					Optional[int]			     =    ShapEPipeline.from_pretrained("openai/shap-e"  )
     UpperCAmelCase_					:					Optional[Any]			     =    pipe.to(lowercase_  )
     pipe.set_progress_bar_config(disable=lowercase_  )

     UpperCAmelCase_					:					Union[str, Any]			     =    torch.Generator(device=lowercase_  ).manual_seed(0  )

     UpperCAmelCase_					:					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


def 					UpperCAmelCase__       (snake_case__							:					list[int]		,   snake_case__							:					int    ):
  """simple docstring"""

  if len(snake_case__    ) < k or k < 0:
    raise ValueError("""Invalid Input"""    )
  _snake_case							:		Optional[int]								=  sum(array[:k]    )
  for i in range(len(snake_case__    ) - k    ):
    _snake_case							:		Optional[Any]								=  current_sum - array[i] + array[i + k]
    _snake_case							:		List[str]								=  max(snake_case__		,   snake_case__    )
  return max_sum


if __name__ == "__main__":
     from doctest import testmod
     from random import randint

     testmod()
     A_						=				[randint(-10_00, 10_00) for i in range(1_00)]
     A_						=				randint(0, 1_10)
     print(F'''The maximum sum of {k} consecutive elements is {max_sum_in_array(array,k)}''')


