





import gc
import unittest

import numpy as np
import torch

from diffusers import AutoencoderKL, DDIMScheduler, DiTPipeline, DPMSolverMultistepScheduler, TransformeraDModel
from diffusers.utils import is_xformers_available, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    CLASS_CONDITIONED_IMAGE_GENERATION_BATCH_PARAMS,
    CLASS_CONDITIONED_IMAGE_GENERATION_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()





class 					A__       (				a__					,    unittest.TestCase      ):




   """simple docstring"""



   __A  :							int			    =    DiTPipeline
   __A  :							Optional[int]			    =    CLASS_CONDITIONED_IMAGE_GENERATION_PARAMS
   __A  :							Tuple			    =    PipelineTesterMixin.required_optional_params - {
       '''latents''',
       '''num_images_per_prompt''',
       '''callback''',
       '''callback_steps''',
   }
   __A  :							Optional[int]			    =    CLASS_CONDITIONED_IMAGE_GENERATION_BATCH_PARAMS
   __A  :							List[Any]			    =    False

   def 				__lowercase						(   self)     ->		Optional[Any]:







          '''simple docstring'''

          torch.manual_seed(0)
          a__		:      Union[str, Any]					=							TransformeraDModel(
              sample_size=16   ,    num_layers=2   ,    patch_size=4   ,    attention_head_dim=8   ,    num_attention_heads=2   ,    in_channels=4   ,    out_channels=8   ,    attention_bias=__a   ,    activation_fn='gelu-approximate'   ,    num_embeds_ada_norm=1000   ,    norm_type='ada_norm_zero'   ,    norm_elementwise_affine=__a   ,    )
          a__		:      Any					=							AutoencoderKL()
          a__		:      List[Any]					=							DDIMScheduler()
          a__		:      Tuple					=							{"""transformer""": transformer.eval(), """vae""": vae.eval(), """scheduler""": scheduler}
          return components

   def 				__lowercase						(   self   ,    lowercase   ,    lowercase=0)     ->		Optional[int]:







          '''simple docstring'''

          if str(__a).startswith('mps'):
                 a__		:      Optional[int]					=							torch.manual_seed(__a)
          else:
                 a__		:      List[Any]					=							torch.Generator(device=__a).manual_seed(__a)
          a__		:      Any					=							{
              """class_labels""": [1],
              """generator""": generator,
              """num_inference_steps""": 2,
              """output_type""": """numpy""",
          }
          return inputs

   def 				__lowercase						(   self)     ->		Optional[Any]:







          '''simple docstring'''

          a__		:      Optional[Any]					=							"""cpu"""

          a__		:      Any					=							self.get_dummy_components()
          a__		:      List[str]					=							self.pipeline_class(**__a)
          pipe.to(__a)
          pipe.set_progress_bar_config(disable=__a)

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

          self.assertEqual(image.shape   ,    (1, 16, 16, 3))
          a__		:      int					=							np.array([0.29_46, 0.66_01, 0.43_29, 0.32_96, 0.41_44, 0.53_19, 0.72_73, 0.50_13, 0.44_57])
          a__		:      str					=							np.abs(image_slice.flatten() - expected_slice).max()
          self.assertLessEqual(__a   ,    1e-3)

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







          '''simple docstring'''

          self._test_inference_batch_single_identical(relax_max_difference=__a   ,    expected_max_diff=1e-3)

   @unittest.skipIf(
       torch_device != 'cuda' or not is_xformers_available()   ,    reason='XFormers attention is only available with CUDA and `xformers` installed'   ,    )
   def 				__lowercase						(   self)     ->		Tuple:







          '''simple docstring'''

          self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3)





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




   """simple docstring"""



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







          '''simple docstring'''

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

   def 				__lowercase						(   self)     ->		Tuple:







          '''simple docstring'''

          a__		:      Tuple					=							torch.manual_seed(0)

          a__		:      Optional[int]					=							DiTPipeline.from_pretrained('facebook/DiT-XL-2-256')
          pipe.to('cuda')

          a__		:      str					=							["""vase""", """umbrella""", """white shark""", """white wolf"""]
          a__		:      Tuple					=							pipe.get_label_ids(__a)

          a__		:      str					=							pipe(__a   ,    generator=__a   ,    num_inference_steps=40   ,    output_type='np').images

          for word, image in zip(__a   ,    __a):
                 a__		:      List[Any]					=							load_numpy(
                     F'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/dit/{word}.npy')
                 assert np.abs((expected_image - image).max()) < 1e-2

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







          '''simple docstring'''

          a__		:      int					=							DiTPipeline.from_pretrained('facebook/DiT-XL-2-512')
          a__		:      Any					=							DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
          pipe.to('cuda')

          a__		:      List[str]					=							["""vase""", """umbrella"""]
          a__		:      Any					=							pipe.get_label_ids(__a)

          a__		:      Optional[Any]					=							torch.manual_seed(0)
          a__		:      Optional[Any]					=							pipe(__a   ,    generator=__a   ,    num_inference_steps=25   ,    output_type='np').images

          for word, image in zip(__a   ,    __a):
                 a__		:      Optional[Any]					=							load_numpy(
                     'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
                     F'/dit/{word}_512.npy')

                 assert np.abs((expected_image - image).max()) < 1e-1






def    __lowerCamelCase   (      A__						: int						,						A__						: int					)     ->    int:
   return int((input_a, input_a).count(0					) == 0					)


def    __lowerCamelCase   (      )     ->    None:
   assert and_gate(0						,						0					) == 0
   assert and_gate(0						,						1					) == 0
   assert and_gate(1						,						0					) == 0
   assert and_gate(1						,						1					) == 1


if __name__ == "__main__":
      test_and_gate()
      print(and_gate(1, 0))
      print(and_gate(0, 0))
      print(and_gate(0, 1))
      print(and_gate(1, 1))





