

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    __lowerCAmelCase       (							_UpperCAmelCase      , unittest.TestCase):
       _a 					=						DiTPipeline
       _a 					=						CLASS_CONDITIONED_IMAGE_GENERATION_PARAMS
       _a 					=						PipelineTesterMixin.required_optional_params - {
           """latents""",
           """num_images_per_prompt""",
           """callback""",
           """callback_steps""",
       }
       _a 					=						CLASS_CONDITIONED_IMAGE_GENERATION_BATCH_PARAMS
       _a 					=						False






       def 					SCREAMING_SNAKE_CASE    (   self:					Optional[Any]				):
         torch.manual_seed(0				)
         lowercase    :List[str]      	=						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=lowercase__       ,					activation_fn="gelu-approximate"       ,					num_embeds_ada_norm=10_00       ,					norm_type="ada_norm_zero"       ,					norm_elementwise_affine=lowercase__       ,					)
         lowercase    :Optional[int]      	=						AutoencoderKL()
         lowercase    :Dict      	=						DDIMScheduler()
         lowercase    :int      	=						{"""transformer""": transformer.eval(), """vae""": vae.eval(), """scheduler""": scheduler}
         return components






       def 					SCREAMING_SNAKE_CASE    (   self:					Optional[Any]       ,					_lowerCAmelCase:					int       ,					_lowerCAmelCase:					Optional[int]=0				):
         if str(lowercase__				).startswith("mps"				):
           lowercase    :Optional[Any]      	=						torch.manual_seed(lowercase__				)
         else:
           lowercase    :Any      	=						torch.Generator(device=lowercase__				).manual_seed(lowercase__				)
         lowercase    :List[Any]      	=						{
             """class_labels""": [1],
             """generator""": generator,
             """num_inference_steps""": 2,
             """output_type""": """numpy""",
         }
         return inputs






       def 					SCREAMING_SNAKE_CASE    (   self:					Optional[Any]				):
         lowercase    :Tuple      	=						"""cpu"""

         lowercase    :Optional[int]      	=						self.get_dummy_components()
         lowercase    :Optional[int]      	=						self.pipeline_class(**lowercase__				)
         pipe.to(lowercase__				)
         pipe.set_progress_bar_config(disable=lowercase__				)

         lowercase    :Optional[Any]      	=						self.get_dummy_inputs(lowercase__				)
         lowercase    :Union[str, Any]      	=						pipe(**lowercase__				).images
         lowercase    :Dict      	=						image[0, -3:, -3:, -1]

         self.assertEqual(image.shape       ,					(1, 16, 16, 3)				)
         lowercase    :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]				)
         lowercase    :Any      	=						np.abs(image_slice.flatten() - expected_slice				).max()
         self.assertLessEqual(lowercase__       ,					1e-3				)






       def 					SCREAMING_SNAKE_CASE    (   self:					str				):
         self._test_inference_batch_single_identical(relax_max_difference=lowercase__       ,					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:					Optional[Any]				):
         self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3				)







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






       def 					SCREAMING_SNAKE_CASE    (   self:					Union[str, Any]				):
         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()






       def 					SCREAMING_SNAKE_CASE    (   self:					Tuple				):
         lowercase    :str      	=						torch.manual_seed(0				)

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

         lowercase    :Union[str, Any]      	=						["""vase""", """umbrella""", """white shark""", """white wolf"""]
         lowercase    :Tuple      	=						pipe.get_label_ids(lowercase__				)

         lowercase    :Optional[Any]      	=						pipe(lowercase__       ,					generator=lowercase__       ,					num_inference_steps=40       ,					output_type="np"				).images

         for word, image in zip(lowercase__       ,					lowercase__				):
           lowercase    :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 					SCREAMING_SNAKE_CASE    (   self:					List[str]				):
         lowercase    :Tuple      	=						DiTPipeline.from_pretrained("facebook/DiT-XL-2-512"				)
         lowercase    :Union[str, Any]      	=						DPMSolverMultistepScheduler.from_config(pipe.scheduler.config				)
         pipe.to("cuda"				)

         lowercase    :Any      	=						["""vase""", """umbrella"""]
         lowercase    :Union[str, Any]      	=						pipe.get_label_ids(lowercase__				)

         lowercase    :Tuple      	=						torch.manual_seed(0				)
         lowercase    :Union[str, Any]      	=						pipe(lowercase__       ,					generator=lowercase__       ,					num_inference_steps=25       ,					output_type="np"				).images

         for word, image in zip(lowercase__       ,					lowercase__				):
           lowercase    :Optional[int]      	=						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       UpperCAmelCase__  (     lowerCamelCase   ):
  return 10 - x * x



def       UpperCAmelCase__  (     lowerCamelCase,			lowerCamelCase   ):
  # Bolzano theory in order to find if there is a root between a and b
  if equation(lowerCamelCase   ) * equation(lowerCamelCase   ) >= 0:
    raise ValueError("Wrong space!"   )

  lowercase    :Optional[int]      	=						a
  while (b - a) >= 0.01:
    # Find middle point
    lowercase    :Optional[Any]      	=						(a + b) / 2
    # Check if middle point is root
    if equation(lowerCamelCase   ) == 0.0:
      break
    # Decide the side to repeat the steps
    if equation(lowerCamelCase   ) * equation(lowerCamelCase   ) < 0:
      lowercase    :Any      	=						c
    else:
      lowercase    :List[Any]      	=						c
  return c


if __name__ == "__main__":
     import doctest

     doctest.testmod()

     print(bisection(-2, 5))
     print(bisection(0, 6))



