


'''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"""
    a													=   ShapEPipeline
    a													=   ["prompt"]
    a													=   ["prompt"]
    a													=   [
        "num_images_per_prompt",
        "num_inference_steps",
        "generator",
        "latents",
        "guidance_scale",
        "frame_size",
        "output_type",
        "return_dict",
    ]
    a													=   False


    @property
    def        A   (  self      :							List[Any]):
           return 32


    @property
    def        A   (  self      :							List[Any]):
           return 32


    @property
    def        A   (  self      :							Dict):
           return self.time_input_dim * 4


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


    @property
    def        A   (  self      :							Optional[Any]):
           _A					:     Tuple     = CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')
           return tokenizer


    @property
    def        A   (  self      :							Optional[int]):
           torch.manual_seed(0)
           _A					:     str     = 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(SCREAMING_SNAKE_CASE)


    @property
    def        A   (  self      :							Dict):
           torch.manual_seed(0)

           _A					:     Dict     = {
               '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,
           }

           _A					:     Any     = PriorTransformer(**SCREAMING_SNAKE_CASE)
           return model


    @property
    def        A   (  self      :							Optional[Any]):
           torch.manual_seed(0)

           _A					:     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,
               ),
           }
           _A					:     Any     = ShapERenderer(**SCREAMING_SNAKE_CASE)
           return model


    def        A   (  self      :							Tuple):
           _A					:     int     = self.dummy_prior
           _A					:     Any     = self.dummy_text_encoder
           _A					:     Optional[Any]     = self.dummy_tokenizer
           _A					:     List[str]     = self.dummy_renderer

           _A					:     List[str]     = HeunDiscreteScheduler(
               beta_schedule='exp'				,							num_train_timesteps=1024				,							prediction_type='sample'				,							use_karras_sigmas=SCREAMING_SNAKE_CASE				,							clip_sample=SCREAMING_SNAKE_CASE				,							clip_sample_range=1.0				,							)
           _A					:     List[Any]     = {
               'prior': prior,
               'text_encoder': text_encoder,
               'tokenizer': tokenizer,
               'renderer': renderer,
               'scheduler': scheduler,
           }

           return components


    def        A   (  self      :							Optional[int]				,							SCREAMING_SNAKE_CASE      :							Optional[Any]				,							SCREAMING_SNAKE_CASE      :							Dict=0):
           if str(SCREAMING_SNAKE_CASE).startswith('mps'):
                  _A					:     int     = torch.manual_seed(SCREAMING_SNAKE_CASE)
           else:
                  _A					:     List[str]     = torch.Generator(device=SCREAMING_SNAKE_CASE).manual_seed(SCREAMING_SNAKE_CASE)
           _A					:     Any     = {
               'prompt': 'horse',
               'generator': generator,
               'num_inference_steps': 1,
               'frame_size': 32,
               'output_type': 'np',
           }
           return inputs


    def        A   (  self      :							List[Any]):
           _A					:     Tuple     = 'cpu'

           _A					:     Optional[Any]     = self.get_dummy_components()

           _A					:     Dict     = self.pipeline_class(**SCREAMING_SNAKE_CASE)
           _A					:     Union[str, Any]     = pipe.to(SCREAMING_SNAKE_CASE)

           pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE)

           _A					:     Any     = pipe(**self.get_dummy_inputs(SCREAMING_SNAKE_CASE))
           _A					:     List[str]     = output.images[0]
           _A					:     int     = image[0, -3:, -3:, -1]

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

           _A					:     List[Any]     = np.array(
               [
                   0.0003_9216,
                   0.0003_9216,
                   0.0003_9216,
                   0.0003_9216,
                   0.0003_9216,
                   0.0003_9216,
                   0.0003_9216,
                   0.0003_9216,
                   0.0003_9216,
               ])

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


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


    def        A   (  self      :							Tuple):
           _A					:     str     = torch_device == 'cpu'
           _A					:     Tuple     = True

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


    def        A   (  self      :							List[Any]):
           _A					:     Optional[Any]     = self.get_dummy_components()
           _A					:     List[str]     = self.pipeline_class(**SCREAMING_SNAKE_CASE)
           _A					:     Optional[int]     = pipe.to(SCREAMING_SNAKE_CASE)
           pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE)

           _A					:     Any     = 1
           _A					:     Tuple     = 2

           _A					:     Tuple     = self.get_dummy_inputs(SCREAMING_SNAKE_CASE)

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

           _A					:     Optional[int]     = 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        A   (  self      :							Optional[Any]):
           # clean up the VRAM after each test
           super().tearDown()
           gc.collect()
           torch.cuda.empty_cache()


    def        A   (  self      :							Tuple):
           _A					:     Optional[int]     = load_numpy(
               'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
               '/shap_e/test_shap_e_np_out.npy')
           _A					:     str     = ShapEPipeline.from_pretrained('openai/shap-e')
           _A					:     Optional[int]     = pipe.to(SCREAMING_SNAKE_CASE)
           pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE)

           _A					:     List[Any]     = torch.Generator(device=SCREAMING_SNAKE_CASE).manual_seed(0)

           _A					:     Tuple     = 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 				lowerCAmelCase__	(    lowerCamelCase					:      int  ,lowerCamelCase					:      list[int]  ,lowerCamelCase					:      int       ):

       def count_of_possible_combinations(lowerCamelCase					:      int       ) -> int:
              if target < 0:
                     return 0
              if target == 0:
                     return 1
              return sum(count_of_possible_combinations(target - item       ) for item in array       )

       return count_of_possible_combinations(lowerCamelCase       )






def 				lowerCAmelCase__	(    lowerCamelCase					:      int  ,lowerCamelCase					:      list[int]  ,lowerCamelCase					:      int       ):

       def count_of_possible_combinations_with_dp_array(
           lowerCamelCase					:      int  ,lowerCamelCase					:      list[int]       ) -> int:
              if target < 0:
                     return 0
              if target == 0:
                     return 1
              if dp_array[target] != -1:
                     return dp_array[target]
              _A					:     Optional[Any]     = sum(
                  count_of_possible_combinations_with_dp_array(target - item  ,lowerCamelCase       )
                  for item in array       )
              _A					:     List[str]     = answer
              return answer

       _A					:     Optional[int]     = [-1] * (target + 1)
       return count_of_possible_combinations_with_dp_array(lowerCamelCase  ,lowerCamelCase       )






def 				lowerCAmelCase__	(    lowerCamelCase					:      int  ,lowerCamelCase					:      list[int]  ,lowerCamelCase					:      int       ):
       _A					:     Dict     = [0] * (target + 1)
       _A					:     List[str]     = 1

       for i in range(1  ,target + 1       ):
              for j in range(lowerCamelCase       ):
                     if i - array[j] >= 0:
                            dp_array[i] += dp_array[i - array[j]]

       return dp_array[target]


if __name__ == "__main__":
   import doctest

   doctest.testmod()
   A				:					Dict    						=			3
   A				:					Union[str, Any]    						=			5
   A				:					Union[str, Any]    						=			[1, 2, 5]
   print(combination_sum_iv(n, array, target))






