




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 				UpperCamelCase_    ( UpperCAmelCase__		,					unittest.TestCase     ):

    '''simple docstring'''






    UpperCAmelCase__							  =      DiTPipeline
    UpperCAmelCase__							  =      CLASS_CONDITIONED_IMAGE_GENERATION_PARAMS
    UpperCAmelCase__							  =      PipelineTesterMixin.required_optional_params - {
        '''latents''',
        '''num_images_per_prompt''',
        '''callback''',
        '''callback_steps''',
    }
    UpperCAmelCase__							  =      CLASS_CONDITIONED_IMAGE_GENERATION_BATCH_PARAMS
    UpperCAmelCase__							  =      False


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





           '''simple docstring'''

           torch.manual_seed(0)
           A__       =    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=UpperCAmelCase__					, activation_fn='''gelu-approximate'''					, num_embeds_ada_norm=1_000					, norm_type='''ada_norm_zero'''					, norm_elementwise_affine=UpperCAmelCase__					, )
           A__       =    AutoencoderKL()
           A__       =    DDIMScheduler()
           A__       =    {'''transformer''': transformer.eval(), '''vae''': vae.eval(), '''scheduler''': scheduler}
           return components


    def        SCREAMING_SNAKE_CASE							(			self      :	List[str]					, UpperCAmelCase__      :	Any					, UpperCAmelCase__      :	int=0)						->Dict:





           '''simple docstring'''

           if str(UpperCAmelCase__).startswith('''mps'''):
                  A__       =    torch.manual_seed(UpperCAmelCase__)
           else:
                  A__       =    torch.Generator(device=UpperCAmelCase__).manual_seed(UpperCAmelCase__)
           A__       =    {
               '''class_labels''': [1],
               '''generator''': generator,
               '''num_inference_steps''': 2,
               '''output_type''': '''numpy''',
           }
           return inputs


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





           '''simple docstring'''

           A__       =    '''cpu'''

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

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

           self.assertEqual(image.shape					, (1, 16, 16, 3))
           A__       =    np.array([0.2946, 0.6601, 0.4329, 0.3296, 0.4144, 0.5319, 0.7273, 0.5013, 0.4457])
           A__       =    np.abs(image_slice.flatten() - expected_slice).max()
           self.assertLessEqual(UpperCAmelCase__					, 1e-3)


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





           '''simple docstring'''

           self._test_inference_batch_single_identical(relax_max_difference=UpperCAmelCase__					, 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        SCREAMING_SNAKE_CASE							(			self      :	int)						->Dict:





           '''simple docstring'''

           self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3)


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

    '''simple docstring'''






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





           '''simple docstring'''

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


    def        SCREAMING_SNAKE_CASE							(			self      :	Dict)						->int:





           '''simple docstring'''

           A__       =    torch.manual_seed(0)

           A__       =    DiTPipeline.from_pretrained('''facebook/DiT-XL-2-256''')
           pipe.to('''cuda''')

           A__       =    ['''vase''', '''umbrella''', '''white shark''', '''white wolf''']
           A__       =    pipe.get_label_ids(UpperCAmelCase__)

           A__       =    pipe(UpperCAmelCase__					, generator=UpperCAmelCase__					, num_inference_steps=40					, output_type='''np''').images

           for word, image in zip(UpperCAmelCase__					, UpperCAmelCase__):
                  A__       =    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        SCREAMING_SNAKE_CASE							(			self      :	str)						->Union[str, Any]:





           '''simple docstring'''

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

           A__       =    ['''vase''', '''umbrella''']
           A__       =    pipe.get_label_ids(UpperCAmelCase__)

           A__       =    torch.manual_seed(0)
           A__       =    pipe(UpperCAmelCase__					, generator=UpperCAmelCase__					, num_inference_steps=25					, output_type='''np''').images

           for word, image in zip(UpperCAmelCase__					, UpperCAmelCase__):
                  A__       =    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 SCREAMING_SNAKE_CASE				(       lowercase_ ,				lowercase_						)   ->       int:



       """simple docstring"""

       return int(input_a == input_a == 0						)







def SCREAMING_SNAKE_CASE				(       )   ->       None:



       """simple docstring"""

       print('''Truth Table of NOR Gate:'''						)
       print('''|   Input 1   |  Input 2  | Output |'''						)
       print(f"""|      0      |    0      |  {nor_gate(0 ,				0						)}     |"""						)
       print(f"""|      0      |    1      |  {nor_gate(0 ,				1						)}     |"""						)
       print(f"""|      1      |    0      |  {nor_gate(1 ,				0						)}     |"""						)
       print(f"""|      1      |    1      |  {nor_gate(1 ,				1						)}     |"""						)


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  main()


