"""simple docstring"""
import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionAttendAndExcitePipeline,
    UNetaDConditionModel,
)
from diffusers.utils import load_numpy, skip_mps, slow
from diffusers.utils.testing_utils import require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


lowercase__ 	=     False




@skip_mps
class        __snake_case	(					__lowerCAmelCase	,				__lowerCAmelCase	,				__lowerCAmelCase	,				unittest.TestCase    ):
      a__				=		StableDiffusionAttendAndExcitePipeline
      a__				=		False
      a__				=		TEXT_TO_IMAGE_PARAMS
      a__				=		TEXT_TO_IMAGE_BATCH_PARAMS.union({"""token_indices"""}    )
      a__				=		TEXT_TO_IMAGE_IMAGE_PARAMS
      a__				=		TEXT_TO_IMAGE_IMAGE_PARAMS



      @classmethod
      def   lowerCamelCase_       (						cls)     ->      Any:





        '''simple docstring'''





        super().setUpClass()
        torch.use_deterministic_algorithms(lowercase)



      @classmethod
      def   lowerCamelCase_       (						cls)     ->      List[Any]:





        '''simple docstring'''





        super().tearDownClass()
        torch.use_deterministic_algorithms(lowercase)



      def   lowerCamelCase_       (						self)     ->      Any:





        '''simple docstring'''





        torch.manual_seed(0)
        a__:					Tuple      							=     UNetaDConditionModel(
            block_out_channels=(32, 64)   ,      layers_per_block=1   ,      sample_size=32   ,      in_channels=4   ,      out_channels=4   ,      down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')   ,      up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')   ,      cross_attention_dim=32   ,      attention_head_dim=(2, 4)   ,      use_linear_projection=lowercase   ,      )
        a__:					Optional[Any]      							=     DDIMScheduler(
            beta_start=0.00085   ,      beta_end=0.012   ,      beta_schedule='scaled_linear'   ,      clip_sample=lowercase   ,      set_alpha_to_one=lowercase   ,      )
        torch.manual_seed(0)
        a__:					str      							=     AutoencoderKL(
            block_out_channels=[32, 64]   ,      in_channels=3   ,      out_channels=3   ,      down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']   ,      up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']   ,      latent_channels=4   ,      sample_size=1_28   ,      )
        torch.manual_seed(0)
        a__:					Optional[int]      							=     CLIPTextConfig(
            bos_token_id=0   ,      eos_token_id=2   ,      hidden_size=32   ,      intermediate_size=37   ,      layer_norm_eps=1e-05   ,      num_attention_heads=4   ,      num_hidden_layers=5   ,      pad_token_id=1   ,      vocab_size=10_00   ,      hidden_act='gelu'   ,      projection_dim=5_12   ,      )
        a__:					List[str]      							=     CLIPTextModel(lowercase)
        a__:					str      							=     CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

        a__:					int      							=     {
            'unet': unet,
            'scheduler': scheduler,
            'vae': vae,
            'text_encoder': text_encoder,
            'tokenizer': tokenizer,
            'safety_checker': None,
            'feature_extractor': None,
        }

        return components



      def   lowerCamelCase_       (						self   ,      lowercase   ,      lowercase=0)     ->      List[Any]:





        '''simple docstring'''





        if str(lowercase).startswith('mps'):
          a__:					Dict      							=     torch.manual_seed(lowercase)
        else:
          a__:					Optional[int]      							=     torch.Generator(device=lowercase).manual_seed(lowercase)
        a__:					List[str]      							=     {
            'prompt': 'a cat and a frog',
            'token_indices': [2, 5],
            'generator': generator,
            'num_inference_steps': 1,
            'guidance_scale': 6.0,
            'output_type': 'numpy',
            'max_iter_to_alter': 2,
            'thresholds': {0: 0.7},
        }
        return inputs



      def   lowerCamelCase_       (						self)     ->      Union[str, Any]:





        '''simple docstring'''





        a__:					int      							=     'cpu'

        a__:					Optional[Any]      							=     self.get_dummy_components()
        a__:					Union[str, Any]      							=     self.pipeline_class(**lowercase)
        pipe.to(lowercase)
        pipe.set_progress_bar_config(disable=lowercase)

        a__:					Optional[int]      							=     self.get_dummy_inputs(lowercase)
        a__:					List[Any]      							=     pipe(**lowercase).images
        a__:					str      							=     image[0, -3:, -3:, -1]

        self.assertEqual(image.shape   ,      (1, 64, 64, 3))
        a__:					List[str]      							=     np.array(
            [0.63905364, 0.62897307, 0.48599017, 0.5133624, 0.5550048, 0.45769516, 0.50326973, 0.5023139, 0.45384496])
        a__:					Dict      							=     np.abs(image_slice.flatten() - expected_slice).max()
        self.assertLessEqual(lowercase   ,      1e-3)



      def   lowerCamelCase_       (						self)     ->      Tuple:





        '''simple docstring'''





        super().test_cpu_offload_forward_pass(expected_max_diff=5e-4)



      def   lowerCamelCase_       (						self)     ->      Optional[int]:





        '''simple docstring'''





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



      def   lowerCamelCase_       (						self)     ->      Optional[int]:





        '''simple docstring'''





        self._test_inference_batch_single_identical(batch_size=2   ,      expected_max_diff=7e-4)



      def   lowerCamelCase_       (						self)     ->      str:





        '''simple docstring'''





        super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3)



      def   lowerCamelCase_       (						self)     ->      str:





        '''simple docstring'''





        super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5e-4)



      def   lowerCamelCase_       (						self)     ->      str:





        '''simple docstring'''





        super().test_save_load_local(expected_max_difference=5e-4)



      def   lowerCamelCase_       (						self)     ->      int:





        '''simple docstring'''





        super().test_save_load_optional_components(expected_max_difference=4e-4)







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



      @classmethod
      def   lowerCamelCase_       (						cls)     ->      Any:





        '''simple docstring'''





        super().setUpClass()
        torch.use_deterministic_algorithms(lowercase)



      @classmethod
      def   lowerCamelCase_       (						cls)     ->      Any:





        '''simple docstring'''





        super().tearDownClass()
        torch.use_deterministic_algorithms(lowercase)



      def   lowerCamelCase_       (						self)     ->      str:





        '''simple docstring'''





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



      def   lowerCamelCase_       (						self)     ->      Dict:





        '''simple docstring'''





        a__:					List[str]      							=     torch.manual_seed(51)

        a__:					int      							=     StableDiffusionAttendAndExcitePipeline.from_pretrained(
            'CompVis/stable-diffusion-v1-4'   ,      safety_checker=lowercase   ,      torch_dtype=torch.floataa)
        pipe.to('cuda')

        a__:					Tuple      							=     'a painting of an elephant with glasses'
        a__:					Dict      							=     [5, 7]

        a__:					Any      							=     pipe(
            prompt=lowercase   ,      token_indices=lowercase   ,      guidance_scale=7.5   ,      generator=lowercase   ,      num_inference_steps=5   ,      max_iter_to_alter=5   ,      output_type='numpy'   ,      ).images[0]

        a__:					int      							=     load_numpy(
            'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/attend-and-excite/elephant_glasses.npy')
        assert np.abs((expected_image - image).max()) < 5e-1



"""simple docstring"""
import unittest

from knapsack import knapsack as k




class        __snake_case	(					unittest.TestCase    ):



      def   lowerCamelCase_       (						self)     ->      Dict:





        '''simple docstring'''





        a__:					List[Any]      							=     0
        a__:					Dict      							=     [0]
        a__:					int      							=     [0]
        a__:					Optional[Any]      							=     len(lowercase)
        self.assertEqual(k.knapsack(lowercase   ,      lowercase   ,      lowercase   ,      lowercase)   ,      0)

        a__:					str      							=     [60]
        a__:					Dict      							=     [10]
        a__:					List[str]      							=     len(lowercase)
        self.assertEqual(k.knapsack(lowercase   ,      lowercase   ,      lowercase   ,      lowercase)   ,      0)



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





        '''simple docstring'''





        a__:					int      							=     3
        a__:					str      							=     [1, 2, 3]
        a__:					Dict      							=     [3, 2, 1]
        a__:					Optional[int]      							=     len(lowercase)
        self.assertEqual(k.knapsack(lowercase   ,      lowercase   ,      lowercase   ,      lowercase)   ,      5)



      def   lowerCamelCase_       (						self)     ->      Union[str, Any]:





        '''simple docstring'''





        a__:					Any      							=     50
        a__:					Optional[int]      							=     [60, 1_00, 1_20]
        a__:					str      							=     [10, 20, 30]
        a__:					int      							=     len(lowercase)
        self.assertEqual(k.knapsack(lowercase   ,      lowercase   ,      lowercase   ,      lowercase)   ,      2_20)


if __name__ == "__main__":
 unittest.main()


