


'''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   snake_case					(					lowercase    ,		unittest.TestCase    ):





  """simple docstring"""




  _lowerCamelCase						=						ShapEPipeline
  _lowerCamelCase						=						["prompt"]
  _lowerCamelCase						=						["prompt"]
  _lowerCamelCase						=						[
      "num_images_per_prompt",
      "num_inference_steps",
      "generator",
      "latents",
      "guidance_scale",
      "frame_size",
      "output_type",
      "return_dict",
  ]
  _lowerCamelCase						=						False






  @property
  def 						snake_case	(					self  ):







   """simple docstring"""
   return 32






  @property
  def 						snake_case	(					self  ):







   """simple docstring"""
   return 32






  @property
  def 						snake_case	(					self  ):







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






  @property
  def 						snake_case	(					self  ):







   """simple docstring"""
   return 8






  @property
  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"  )
   return tokenizer






  @property
  def 						snake_case	(					self  ):







   """simple docstring"""
   torch.manual_seed(0  )
   lowerCamelCase_  				=						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(UpperCamelCase  )






  @property
  def 						snake_case	(					self  ):







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

   lowerCamelCase_  				=						{
       "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,
   }

   lowerCamelCase_  				=						PriorTransformer(**UpperCamelCase  )
   return model






  @property
  def 						snake_case	(					self  ):







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

   lowerCamelCase_  				=						{
       "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,
       ),
   }
   lowerCamelCase_  				=						ShapERenderer(**UpperCamelCase  )
   return model






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						self.dummy_prior
   lowerCamelCase_  				=						self.dummy_text_encoder
   lowerCamelCase_  				=						self.dummy_tokenizer
   lowerCamelCase_  				=						self.dummy_renderer

   lowerCamelCase_  				=						HeunDiscreteScheduler(
       beta_schedule="exp"    ,						num_train_timesteps=1024    ,						prediction_type="sample"    ,						use_karras_sigmas=UpperCamelCase    ,						clip_sample=UpperCamelCase    ,						clip_sample_range=1.0    ,						)
   lowerCamelCase_  				=						{
       "prior": prior,
       "text_encoder": text_encoder,
       "tokenizer": tokenizer,
       "renderer": renderer,
       "scheduler": scheduler,
   }

   return components






  def 						snake_case	(					self    ,						UpperCamelCase    ,						UpperCamelCase=0  ):







   """simple docstring"""
   if str(UpperCamelCase  ).startswith("mps"  ):
    lowerCamelCase_  				=						torch.manual_seed(UpperCamelCase  )
   else:
    lowerCamelCase_  				=						torch.Generator(device=UpperCamelCase  ).manual_seed(UpperCamelCase  )
   lowerCamelCase_  				=						{
       "prompt": "horse",
       "generator": generator,
       "num_inference_steps": 1,
       "frame_size": 32,
       "output_type": "np",
   }
   return inputs






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						"cpu"

   lowerCamelCase_  				=						self.get_dummy_components()

   lowerCamelCase_  				=						self.pipeline_class(**UpperCamelCase  )
   lowerCamelCase_  				=						pipe.to(UpperCamelCase  )

   pipe.set_progress_bar_config(disable=UpperCamelCase  )

   lowerCamelCase_  				=						pipe(**self.get_dummy_inputs(UpperCamelCase  )  )
   lowerCamelCase_  				=						output.images[0]
   lowerCamelCase_  				=						image[0, -3:, -3:, -1]

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

   lowerCamelCase_  				=						np.array(
       [
           0.00_039_216,
           0.00_039_216,
           0.00_039_216,
           0.00_039_216,
           0.00_039_216,
           0.00_039_216,
           0.00_039_216,
           0.00_039_216,
           0.00_039_216,
       ]  )

   assert np.abs(image_slice.flatten() - expected_slice  ).max() < 1e-2






  def 						snake_case	(					self  ):







   """simple docstring"""
   self._test_inference_batch_consistent(batch_sizes=[1, 2]  )






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						torch_device == "cpu"
   lowerCamelCase_  				=						True

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







  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						self.get_dummy_components()
   lowerCamelCase_  				=						self.pipeline_class(**UpperCamelCase  )
   lowerCamelCase_  				=						pipe.to(UpperCamelCase  )
   pipe.set_progress_bar_config(disable=UpperCamelCase  )

   lowerCamelCase_  				=						1
   lowerCamelCase_  				=						2

   lowerCamelCase_  				=						self.get_dummy_inputs(UpperCamelCase  )

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

   lowerCamelCase_  				=						pipe(**UpperCamelCase    ,						num_images_per_prompt=UpperCamelCase  )[0]

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





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





  """simple docstring"""




  def 						snake_case	(					self  ):







   """simple docstring"""
   super().tearDown()
   gc.collect()
   torch.cuda.empty_cache()







  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						load_numpy(
       "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
       "/shap_e/test_shap_e_np_out.npy"  )
   lowerCamelCase_  				=						ShapEPipeline.from_pretrained("openai/shap-e"  )
   lowerCamelCase_  				=						pipe.to(UpperCamelCase  )
   pipe.set_progress_bar_config(disable=UpperCamelCase  )

   lowerCamelCase_  				=						torch.Generator(device=UpperCamelCase  ).manual_seed(0  )

   lowerCamelCase_  				=						pipe(
       "a shark"    ,						generator=UpperCamelCase    ,						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(UpperCamelCase    ,						UpperCamelCase  )







'''simple docstring'''

from collections.abc import Sequence





def __snake_case      (   UpperCAmelCase_		:		Sequence[int] | None = None	):
 if nums is None or not nums:
  raise ValueError("Input sequence should not be empty"	)

 lowerCamelCase_  				=						nums[0]
 for i in range(1      ,       len(UpperCAmelCase_	)	):
  lowerCamelCase_  				=						nums[i]
  lowerCamelCase_  				=						max(UpperCAmelCase_      ,       ans + num      ,       UpperCAmelCase_	)

 return ans


if __name__ == "__main__":
     import doctest

     doctest.testmod()

     # Try on a sample input from the user
     a_						:       Any      			=				int(input("""Enter number of elements : """).strip())
     a_						:       Union[str, Any]      			=				list(map(int, input("""\nEnter the numbers : """).strip().split()))[:n]
     print(max_subsequence_sum(array))



