"""simple docstring"""


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 (						lowerCAmelCase_		,							unittest.TestCase      ):
    _snake_case   :     Tuple   							=							DiTPipeline
    _snake_case   :     int   							=							CLASS_CONDITIONED_IMAGE_GENERATION_PARAMS
    _snake_case   :     List[str]   							=							PipelineTesterMixin.required_optional_params - {
        'latents',
        'num_images_per_prompt',
        'callback',
        'callback_steps',
    }
    _snake_case   :     Tuple   							=							CLASS_CONDITIONED_IMAGE_GENERATION_BATCH_PARAMS
    _snake_case   :     int   							=							False


    def    lowerCAmelCase_     (    self		:     str    ):
      torch.manual_seed(0    )
      _UpperCAmelCase         =					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=__lowerCAmelCase      , activation_fn="""gelu-approximate"""      , num_embeds_ada_norm=1000      , norm_type="""ada_norm_zero"""      , norm_elementwise_affine=__lowerCAmelCase      , )
      _UpperCAmelCase         =					AutoencoderKL()
      _UpperCAmelCase         =					DDIMScheduler()
      _UpperCAmelCase         =					{"""transformer""": transformer.eval(), """vae""": vae.eval(), """scheduler""": scheduler}
      return components


    def    lowerCAmelCase_     (    self		:     Tuple      , __lowerCAmelCase		:     Any      , __lowerCAmelCase		:     List[Any]=0    ):
      if str(__lowerCAmelCase    ).startswith("""mps"""    ):
        _UpperCAmelCase         =					torch.manual_seed(__lowerCAmelCase    )
      else:
        _UpperCAmelCase         =					torch.Generator(device=__lowerCAmelCase    ).manual_seed(__lowerCAmelCase    )
      _UpperCAmelCase         =					{
          """class_labels""": [1],
          """generator""": generator,
          """num_inference_steps""": 2,
          """output_type""": """numpy""",
      }
      return inputs


    def    lowerCAmelCase_     (    self		:     Any    ):
      _UpperCAmelCase         =					"""cpu"""

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

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

      self.assertEqual(image.shape      , (1, 16, 16, 3)    )
      _UpperCAmelCase         =					np.array([0.2_946, 0.6_601, 0.4_329, 0.3_296, 0.4_144, 0.5_319, 0.7_273, 0.5_013, 0.4_457]    )
      _UpperCAmelCase         =					np.abs(image_slice.flatten() - expected_slice    ).max()
      self.assertLessEqual(__lowerCAmelCase      , 1e-3    )


    def    lowerCAmelCase_     (    self		:     Optional[int]    ):
      self._test_inference_batch_single_identical(relax_max_difference=__lowerCAmelCase      , 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    lowerCAmelCase_     (    self		:     Optional[int]    ):
      self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3    )



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


    def    lowerCAmelCase_     (    self		:     int    ):
      super().tearDown()
      gc.collect()
      torch.cuda.empty_cache()


    def    lowerCAmelCase_     (    self		:     List[Any]    ):
      _UpperCAmelCase         =					torch.manual_seed(0    )

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

      _UpperCAmelCase         =					["""vase""", """umbrella""", """white shark""", """white wolf"""]
      _UpperCAmelCase         =					pipe.get_label_ids(__lowerCAmelCase    )

      _UpperCAmelCase         =					pipe(__lowerCAmelCase      , generator=__lowerCAmelCase      , num_inference_steps=40      , output_type="""np"""    ).images

      for word, image in zip(__lowerCAmelCase      , __lowerCAmelCase    ):
        _UpperCAmelCase         =					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    lowerCAmelCase_     (    self		:     int    ):
      _UpperCAmelCase         =					DiTPipeline.from_pretrained("""facebook/DiT-XL-2-512"""    )
      _UpperCAmelCase         =					DPMSolverMultistepScheduler.from_config(pipe.scheduler.config    )
      pipe.to("""cuda"""    )

      _UpperCAmelCase         =					["""vase""", """umbrella"""]
      _UpperCAmelCase         =					pipe.get_label_ids(__lowerCAmelCase    )

      _UpperCAmelCase         =					torch.manual_seed(0    )
      _UpperCAmelCase         =					pipe(__lowerCAmelCase      , generator=__lowerCAmelCase      , num_inference_steps=25      , output_type="""np"""    ).images

      for word, image in zip(__lowerCAmelCase      , __lowerCAmelCase    ):
        _UpperCAmelCase         =					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

"""simple docstring"""


UpperCAmelCase__     						=  {
    """meter""": """m""",
    """kilometer""": """km""",
    """megametre""": """Mm""",
    """gigametre""": """Gm""",
    """terametre""": """Tm""",
    """petametre""": """Pm""",
    """exametre""": """Em""",
    """zettametre""": """Zm""",
    """yottametre""": """Ym""",
}
# Exponent of the factor(meter)
UpperCAmelCase__     						=  {
    """m""": 0,
    """km""": 3,
    """Mm""": 6,
    """Gm""": 9,
    """Tm""": 1_2,
    """Pm""": 1_5,
    """Em""": 1_8,
    """Zm""": 2_1,
    """Ym""": 2_4,
}






def 			__UpperCAmelCase    (	lowercase      ,lowercase      ,lowercase						):







  """simple docstring"""
  _UpperCAmelCase         =					from_type.lower().strip("""s"""						)
  _UpperCAmelCase         =					to_type.lower().strip("""s"""						)

  _UpperCAmelCase         =					UNIT_SYMBOL.get(lowercase      ,lowercase						)
  _UpperCAmelCase         =					UNIT_SYMBOL.get(lowercase      ,lowercase						)

  if from_sanitized not in METRIC_CONVERSION:
    _UpperCAmelCase         =					(
        f'''Invalid \'from_type\' value: {from_type!r}.\n'''
        f'''Conversion abbreviations are: {", ".join(lowercase						)}'''
    )
    raise ValueError(lowercase						)
  if to_sanitized not in METRIC_CONVERSION:
    _UpperCAmelCase         =					(
        f'''Invalid \'to_type\' value: {to_type!r}.\n'''
        f'''Conversion abbreviations are: {", ".join(lowercase						)}'''
    )
    raise ValueError(lowercase						)
  _UpperCAmelCase         =					METRIC_CONVERSION[from_sanitized]
  _UpperCAmelCase         =					METRIC_CONVERSION[to_sanitized]
  _UpperCAmelCase         =					1

  if from_exponent > to_exponent:
    _UpperCAmelCase         =					from_exponent - to_exponent
  else:
    _UpperCAmelCase         =					-(to_exponent - from_exponent)

  return value * pow(10      ,lowercase						)


if __name__ == "__main__":
    from doctest import testmod

    testmod()
