

'''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__   (      a ,					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       UpperCAmelCase__		(		self					:       Any			)  -> List[str]:


      """simple docstring"""




      return 32
 @property
 def       UpperCAmelCase__		(		self					:       Optional[Any]			)  -> Dict:


      """simple docstring"""




      return 32
 @property
 def       UpperCAmelCase__		(		self					:       Any			)  -> int:


      """simple docstring"""




      return self.time_input_dim * 4
 @property
 def       UpperCAmelCase__		(		self					:       int			)  -> Any:


      """simple docstring"""




      return 8
 @property
 def       UpperCAmelCase__		(		self					:       Union[str, Any]			)  -> Optional[int]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""			)
      return tokenizer
 @property
 def       UpperCAmelCase__		(		self					:       Union[str, Any]			)  -> Any:


      """simple docstring"""




      torch.manual_seed(0			)
      __SCREAMING_SNAKE_CASE     =      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=1_000					,							)
      return CLIPTextModelWithProjection(__SCREAMING_SNAKE_CASE			)
 @property
 def       UpperCAmelCase__		(		self					:       Any			)  -> int:


      """simple docstring"""




      torch.manual_seed(0			)

      __SCREAMING_SNAKE_CASE     =      {
          """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     =      PriorTransformer(**__SCREAMING_SNAKE_CASE			)
      return model
 @property
 def       UpperCAmelCase__		(		self					:       List[str]			)  -> Tuple:


      """simple docstring"""




      torch.manual_seed(0			)

      __SCREAMING_SNAKE_CASE     =      {
          """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     =      ShapERenderer(**__SCREAMING_SNAKE_CASE			)
      return model
 def       UpperCAmelCase__		(		self					:       Dict			)  -> List[str]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      self.dummy_prior
      __SCREAMING_SNAKE_CASE     =      self.dummy_text_encoder
      __SCREAMING_SNAKE_CASE     =      self.dummy_tokenizer
      __SCREAMING_SNAKE_CASE     =      self.dummy_renderer

      __SCREAMING_SNAKE_CASE     =      HeunDiscreteScheduler(
          beta_schedule="""exp"""					,							num_train_timesteps=1_024					,							prediction_type="""sample"""					,							use_karras_sigmas=__SCREAMING_SNAKE_CASE					,							clip_sample=__SCREAMING_SNAKE_CASE					,							clip_sample_range=1.0					,							)
      __SCREAMING_SNAKE_CASE     =      {
          """prior""": prior,
          """text_encoder""": text_encoder,
          """tokenizer""": tokenizer,
          """renderer""": renderer,
          """scheduler""": scheduler,
      }

      return components
 def       UpperCAmelCase__		(		self					:       Optional[int]					,							__SCREAMING_SNAKE_CASE					:       List[str]					,							__SCREAMING_SNAKE_CASE					:       int=0			)  -> Union[str, Any]:


      """simple docstring"""




      if str(__SCREAMING_SNAKE_CASE			).startswith("""mps"""			):
           __SCREAMING_SNAKE_CASE     =      torch.manual_seed(__SCREAMING_SNAKE_CASE			)
      else:
           __SCREAMING_SNAKE_CASE     =      torch.Generator(device=__SCREAMING_SNAKE_CASE			).manual_seed(__SCREAMING_SNAKE_CASE			)
      __SCREAMING_SNAKE_CASE     =      {
          """prompt""": """horse""",
          """generator""": generator,
          """num_inference_steps""": 1,
          """frame_size""": 32,
          """output_type""": """np""",
      }
      return inputs
 def       UpperCAmelCase__		(		self					:       int			)  -> Optional[Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      """cpu"""

      __SCREAMING_SNAKE_CASE     =      self.get_dummy_components()

      __SCREAMING_SNAKE_CASE     =      self.pipeline_class(**__SCREAMING_SNAKE_CASE			)
      __SCREAMING_SNAKE_CASE     =      pipe.to(__SCREAMING_SNAKE_CASE			)

      pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE			)

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

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

      __SCREAMING_SNAKE_CASE     =      np.array(
          [
              0.00039216,
              0.00039216,
              0.00039216,
              0.00039216,
              0.00039216,
              0.00039216,
              0.00039216,
              0.00039216,
              0.00039216,
          ]			)

      assert np.abs(image_slice.flatten() - expected_slice			).max() < 1E-2
 def       UpperCAmelCase__		(		self					:       List[str]			)  -> List[Any]:


      """simple docstring"""




      self._test_inference_batch_consistent(batch_sizes=[1, 2]			)
 def       UpperCAmelCase__		(		self					:       str			)  -> Dict:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      torch_device == """cpu"""
      __SCREAMING_SNAKE_CASE     =      True

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


 def       UpperCAmelCase__		(		self					:       Any			)  -> List[Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      self.get_dummy_components()
      __SCREAMING_SNAKE_CASE     =      self.pipeline_class(**__SCREAMING_SNAKE_CASE			)
      __SCREAMING_SNAKE_CASE     =      pipe.to(__SCREAMING_SNAKE_CASE			)
      pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE			)

      __SCREAMING_SNAKE_CASE     =      1
      __SCREAMING_SNAKE_CASE     =      2

      __SCREAMING_SNAKE_CASE     =      self.get_dummy_inputs(__SCREAMING_SNAKE_CASE			)

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

      __SCREAMING_SNAKE_CASE     =      pipe(**__SCREAMING_SNAKE_CASE					,							num_images_per_prompt=__SCREAMING_SNAKE_CASE			)[0]

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







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



 """simple docstring"""



 def       UpperCAmelCase__		(		self					:       List[Any]			)  -> Dict:


      """simple docstring"""




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


 def       UpperCAmelCase__		(		self					:       Tuple			)  -> int:


      """simple docstring"""




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

      __SCREAMING_SNAKE_CASE     =      torch.Generator(device=__SCREAMING_SNAKE_CASE			).manual_seed(0			)

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









'''simple docstring'''



def    a__       (  a__      ,    a__						):




     """simple docstring"""


     __SCREAMING_SNAKE_CASE     =      int(a__						)

     # Initialize Result
     __SCREAMING_SNAKE_CASE     =      []

     # Traverse through all denomination
     for denomination in reversed(a__						):
          # Find denominations
          while int(a__						) >= int(a__						):
               total_value -= int(a__						)
               answer.append(a__						)  # Append the "answers" array

     return answer


# Driver Code
if __name__ == "__main__":
  UpperCAmelCase :       Dict			   =     []
  UpperCAmelCase :       List[str]			   =     '0'

  if (
      input('Do you want to enter your denominations ? (yY/n): ').strip().lower()
      == "y"
  ):
    UpperCAmelCase :       List[str]			   =     int(input('Enter the number of denominations you want to add: ').strip())

    for i in range(0, n):
      denominations.append(int(input(f"""Denomination {i}: """).strip()))
    UpperCAmelCase :       str			   =     input('Enter the change you want to make in Indian Currency: ').strip()
  else:
    # All denominations of Indian Currency if user does not enter
    UpperCAmelCase :       int			   =     [1, 2, 5, 1_0, 2_0, 5_0, 1_0_0, 5_0_0, 2_0_0_0]
    UpperCAmelCase :       Any			   =     input('Enter the change you want to make: ').strip()

  if int(value) == 0 or int(value) < 0:
    print('The total value cannot be zero or negative.')

  else:
    print(f"""Following is minimal change for {value}: """)
    UpperCAmelCase :       Any			   =     find_minimum_change(denominations, value)
    # Print result
    for i in range(len(answer)):
      print(answer[i], end=' ')






