import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    PNDMScheduler,
    StableDiffusionLDMaDPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import nightly, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS


enable_full_determinism()







class __snake_case       (		unittest.TestCase	):
   lowerCAmelCase_														=							StableDiffusionLDMaDPipeline
   lowerCAmelCase_														=							TEXT_TO_IMAGE_PARAMS
   lowerCAmelCase_														=							TEXT_TO_IMAGE_BATCH_PARAMS
   lowerCAmelCase_														=							TEXT_TO_IMAGE_IMAGE_PARAMS




   def 			__a		(					self    :       str   ):



     """simple docstring"""






     torch.manual_seed(0   )
     SCREAMING_SNAKE_CASE__    							=   UNetaDConditionModel(
         block_out_channels=(32, 64) ,			layers_per_block=2 ,			sample_size=32 ,			in_channels=4 ,			out_channels=4 ,			down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""") ,			up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""") ,			cross_attention_dim=32 ,			)
     SCREAMING_SNAKE_CASE__    							=   DDIMScheduler(
         beta_start=0.0_00_85 ,			beta_end=0.0_12 ,			beta_schedule="""scaled_linear""" ,			clip_sample=_lowercase ,			set_alpha_to_one=_lowercase ,			)
     torch.manual_seed(0   )
     SCREAMING_SNAKE_CASE__    							=   AutoencoderKL(
         block_out_channels=[32, 64] ,			in_channels=6 ,			out_channels=6 ,			down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""] ,			up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""] ,			latent_channels=4 ,			)
     torch.manual_seed(0   )
     SCREAMING_SNAKE_CASE__    							=   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 ,			)
     SCREAMING_SNAKE_CASE__    							=   CLIPTextModel(_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""   )

     SCREAMING_SNAKE_CASE__    							=   {
         """unet""": unet,
         """scheduler""": scheduler,
         """vae""": vae,
         """text_encoder""": text_encoder,
         """tokenizer""": tokenizer,
         """safety_checker""": None,
         """feature_extractor""": None,
     }
     return components




   def 			__a		(					self    :       Any ,			_lowercase    :       Union[str, Any] ,			_lowercase    :       List[str]=0   ):



     """simple docstring"""






     if str(_lowercase   ).startswith("""mps"""   ):
       SCREAMING_SNAKE_CASE__    							=   torch.manual_seed(_lowercase   )
     else:
       SCREAMING_SNAKE_CASE__    							=   torch.Generator(device=_lowercase   ).manual_seed(_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   {
         """prompt""": """A painting of a squirrel eating a burger""",
         """generator""": generator,
         """num_inference_steps""": 2,
         """guidance_scale""": 6.0,
         """output_type""": """numpy""",
     }
     return inputs




   def 			__a		(					self    :       List[Any]   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   """cpu"""  # ensure determinism for the device-dependent torch.Generator

     SCREAMING_SNAKE_CASE__    							=   self.get_dummy_components()
     SCREAMING_SNAKE_CASE__    							=   StableDiffusionLDMaDPipeline(**_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   ldmad_pipe.to(_lowercase   )
     ldmad_pipe.set_progress_bar_config(disable=_lowercase   )

     SCREAMING_SNAKE_CASE__    							=   self.get_dummy_inputs(_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   ldmad_pipe(**_lowercase   )
     SCREAMING_SNAKE_CASE__							,  SCREAMING_SNAKE_CASE__    							=   output.rgb, output.depth

     SCREAMING_SNAKE_CASE__    							=   rgb[0, -3:, -3:, -1]
     SCREAMING_SNAKE_CASE__    							=   depth[0, -3:, -1]

     assert rgb.shape == (1, 64, 64, 3)
     assert depth.shape == (1, 64, 64)

     SCREAMING_SNAKE_CASE__    							=   np.array(
         [0.37_33_81_76, 0.7_02_47, 0.74_20_31_93, 0.51_64_36_04, 0.58_25_67_93, 0.60_93_21_36, 0.4_18_10_95, 0.48_35_58_77, 0.46_53_52_62]   )
     SCREAMING_SNAKE_CASE__    							=   np.array([1_03.4_67_27, 85.81_20_04, 87.84_92_36]   )

     assert np.abs(image_slice_rgb.flatten() - expected_slice_rgb   ).max() < 1E-2
     assert np.abs(image_slice_depth.flatten() - expected_slice_depth   ).max() < 1E-2




   def 			__a		(					self    :       Any   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   self.get_dummy_components()
     SCREAMING_SNAKE_CASE__    							=   StableDiffusionLDMaDPipeline(**_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   ldmad_pipe.to(_lowercase   )
     ldmad_pipe.set_progress_bar_config(disable=_lowercase   )

     SCREAMING_SNAKE_CASE__    							=   self.get_dummy_inputs(_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   3 * [inputs["""prompt"""]]

     # forward
     SCREAMING_SNAKE_CASE__    							=   ldmad_pipe(**_lowercase   )
     SCREAMING_SNAKE_CASE__							,  SCREAMING_SNAKE_CASE__    							=   output.rgb, output.depth
     SCREAMING_SNAKE_CASE__    							=   rgb_slice_a[0, -3:, -3:, -1]
     SCREAMING_SNAKE_CASE__    							=   depth_slice_a[0, -3:, -1]

     SCREAMING_SNAKE_CASE__    							=   self.get_dummy_inputs(_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   3 * [inputs.pop("""prompt"""   )]

     SCREAMING_SNAKE_CASE__    							=   ldmad_pipe.tokenizer(
         _lowercase ,			padding="""max_length""" ,			max_length=ldmad_pipe.tokenizer.model_max_length ,			truncation=_lowercase ,			return_tensors="""pt""" ,			)
     SCREAMING_SNAKE_CASE__    							=   text_inputs["""input_ids"""].to(_lowercase   )

     SCREAMING_SNAKE_CASE__    							=   ldmad_pipe.text_encoder(_lowercase   )[0]

     SCREAMING_SNAKE_CASE__    							=   prompt_embeds

     # forward
     SCREAMING_SNAKE_CASE__    							=   ldmad_pipe(**_lowercase   )
     SCREAMING_SNAKE_CASE__							,  SCREAMING_SNAKE_CASE__    							=   output.rgb, output.depth
     SCREAMING_SNAKE_CASE__    							=   rgb_slice_a[0, -3:, -3:, -1]
     SCREAMING_SNAKE_CASE__    							=   depth_slice_a[0, -3:, -1]

     assert np.abs(rgb_slice_a.flatten() - rgb_slice_a.flatten()   ).max() < 1E-4
     assert np.abs(depth_slice_a.flatten() - depth_slice_a.flatten()   ).max() < 1E-4




   def 			__a		(					self    :       List[str]   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   """cpu"""  # ensure determinism for the device-dependent torch.Generator
     SCREAMING_SNAKE_CASE__    							=   self.get_dummy_components()
     SCREAMING_SNAKE_CASE__    							=   PNDMScheduler(skip_prk_steps=_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   StableDiffusionLDMaDPipeline(**_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   ldmad_pipe.to(_lowercase   )
     ldmad_pipe.set_progress_bar_config(disable=_lowercase   )

     SCREAMING_SNAKE_CASE__    							=   self.get_dummy_inputs(_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   """french fries"""
     SCREAMING_SNAKE_CASE__    							=   ldmad_pipe(**_lowercase ,			negative_prompt=_lowercase   )

     SCREAMING_SNAKE_CASE__							,  SCREAMING_SNAKE_CASE__    							=   output.rgb, output.depth
     SCREAMING_SNAKE_CASE__    							=   rgb[0, -3:, -3:, -1]
     SCREAMING_SNAKE_CASE__    							=   depth[0, -3:, -1]

     assert rgb.shape == (1, 64, 64, 3)
     assert depth.shape == (1, 64, 64)

     SCREAMING_SNAKE_CASE__    							=   np.array(
         [0.3_70_44, 0.71_81_15_03, 0.7_22_32_51, 0.48_60_36_75, 0.5_63_83_91, 0.6_36_49_48, 0.42_83_37_04, 0.4_90_13_15, 0.47_92_62_17]   )
     SCREAMING_SNAKE_CASE__    							=   np.array([1_07.8_47_38, 84.6_28_02, 89.96_21_35]   )
     assert np.abs(rgb_slice.flatten() - expected_slice_rgb   ).max() < 1E-2
     assert np.abs(depth_slice.flatten() - expected_slice_depth   ).max() < 1E-2







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




   def 			__a		(					self    :       Any   ):



     """simple docstring"""






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




   def 			__a		(					self    :       List[Any] ,			_lowercase    :       List[Any] ,			_lowercase    :       Union[str, Any]="cpu" ,			_lowercase    :       Any=torch.floataa ,			_lowercase    :       str=0   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   torch.Generator(device=_lowercase   ).manual_seed(_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   np.random.RandomState(_lowercase   ).standard_normal((1, 4, 64, 64)   )
     SCREAMING_SNAKE_CASE__    							=   torch.from_numpy(_lowercase   ).to(device=_lowercase ,			dtype=_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   {
         """prompt""": """a photograph of an astronaut riding a horse""",
         """latents""": latents,
         """generator""": generator,
         """num_inference_steps""": 3,
         """guidance_scale""": 7.5,
         """output_type""": """numpy""",
     }
     return inputs




   def 			__a		(					self    :       Tuple   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   StableDiffusionLDMaDPipeline.from_pretrained("""Intel/ldm3d"""   )
     SCREAMING_SNAKE_CASE__    							=   ldmad_pipe.to(_lowercase   )
     ldmad_pipe.set_progress_bar_config(disable=_lowercase   )

     SCREAMING_SNAKE_CASE__    							=   self.get_inputs(_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   ldmad_pipe(**_lowercase   )
     SCREAMING_SNAKE_CASE__							,  SCREAMING_SNAKE_CASE__    							=   output.rgb, output.depth
     SCREAMING_SNAKE_CASE__    							=   rgb[0, -3:, -3:, -1].flatten()
     SCREAMING_SNAKE_CASE__    							=   rgb[0, -3:, -1].flatten()

     assert rgb.shape == (1, 5_12, 5_12, 3)
     assert depth.shape == (1, 5_12, 5_12)

     SCREAMING_SNAKE_CASE__    							=   np.array(
         [0.53_80_54_65, 0.56_70_73_05, 0.5_48_65_15, 0.57_01_22_36, 0.5_81_45_11, 0.56_25_34_87, 0.54_84_30_14, 0.55_09_22_63, 0.6_45_97_06]   )
     SCREAMING_SNAKE_CASE__    							=   np.array(
         [0.9_26_37_81, 0.6_67_86_72, 0.5_48_65_15, 0.92_20_21_45, 0.67_83_11_35, 0.56_25_34_87, 0.9_24_16_94, 0.7_55_14_78, 0.6_45_97_06]   )
     assert np.abs(rgb_slice - expected_slice_rgb   ).max() < 3E-3
     assert np.abs(depth_slice - expected_slice_depth   ).max() < 3E-3







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




   def 			__a		(					self    :       List[str]   ):



     """simple docstring"""






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




   def 			__a		(					self    :       Optional[Any] ,			_lowercase    :       Optional[Any] ,			_lowercase    :       Any="cpu" ,			_lowercase    :       Tuple=torch.floataa ,			_lowercase    :       Any=0   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   torch.Generator(device=_lowercase   ).manual_seed(_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   np.random.RandomState(_lowercase   ).standard_normal((1, 4, 64, 64)   )
     SCREAMING_SNAKE_CASE__    							=   torch.from_numpy(_lowercase   ).to(device=_lowercase ,			dtype=_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   {
         """prompt""": """a photograph of an astronaut riding a horse""",
         """latents""": latents,
         """generator""": generator,
         """num_inference_steps""": 50,
         """guidance_scale""": 7.5,
         """output_type""": """numpy""",
     }
     return inputs




   def 			__a		(					self    :       Any   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   StableDiffusionLDMaDPipeline.from_pretrained("""Intel/ldm3d"""   ).to(_lowercase   )
     ldmad_pipe.set_progress_bar_config(disable=_lowercase   )

     SCREAMING_SNAKE_CASE__    							=   self.get_inputs(_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   ldmad_pipe(**_lowercase   )
     SCREAMING_SNAKE_CASE__							,  SCREAMING_SNAKE_CASE__    							=   output.rgb, output.depth

     SCREAMING_SNAKE_CASE__    							=   0.49_55_86
     SCREAMING_SNAKE_CASE__    							=   0.33_79_55_15
     SCREAMING_SNAKE_CASE__    							=   1_12.4_85_18
     SCREAMING_SNAKE_CASE__    							=   98.48_97_46
     assert np.abs(expected_rgb_mean - rgb.mean()   ) < 1E-3
     assert np.abs(expected_rgb_std - rgb.std()   ) < 1E-3
     assert np.abs(expected_depth_mean - depth.mean()   ) < 1E-3
     assert np.abs(expected_depth_std - depth.std()   ) < 1E-3




   def 			__a		(					self    :       Tuple   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   StableDiffusionLDMaDPipeline.from_pretrained("""Intel/ldm3d-4c"""   ).to(_lowercase   )
     ldmad_pipe.set_progress_bar_config(disable=_lowercase   )

     SCREAMING_SNAKE_CASE__    							=   self.get_inputs(_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   ldmad_pipe(**_lowercase   )
     SCREAMING_SNAKE_CASE__							,  SCREAMING_SNAKE_CASE__    							=   output.rgb, output.depth

     SCREAMING_SNAKE_CASE__    							=   0.4_19_41_27
     SCREAMING_SNAKE_CASE__    							=   0.35_37_55_86
     SCREAMING_SNAKE_CASE__    							=   0.5_63_85_02
     SCREAMING_SNAKE_CASE__    							=   0.34_68_61_03

     assert rgb.shape == (1, 5_12, 5_12, 3)
     assert depth.shape == (1, 5_12, 5_12, 1)
     assert np.abs(expected_rgb_mean - rgb.mean()   ) < 1E-3
     assert np.abs(expected_rgb_std - rgb.std()   ) < 1E-3
     assert np.abs(expected_depth_mean - depth.mean()   ) < 1E-3
     assert np.abs(expected_depth_std - depth.std()   ) < 1E-3

from __future__ import annotations

from collections.abc import Iterator
from typing import Any







class __snake_case       :




   def __init__(					self    :       Union[str, Any] ,			_lowercase    :       Any   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   data
     SCREAMING_SNAKE_CASE__    							=   None







class __snake_case       :




   def __init__(					self    :       List[Any]   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   None
     SCREAMING_SNAKE_CASE__    							=   None




   def __iter__(					self    :       Tuple   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   self.head
     while self.head:
       yield node.data
       SCREAMING_SNAKE_CASE__    							=   node.next
       if node == self.head:
         break




   def __len__(					self    :       int   ):



     """simple docstring"""






     return sum(1 for _ in self   )




   def __repr__(					self    :       Optional[int]   ):



     """simple docstring"""






     return "->".join(str(_lowercase   ) for item in iter(self   )   )




   def 			__a		(					self    :       Optional[int] ,			_lowercase    :       Any   ):



     """simple docstring"""






     self.insert_nth(len(self   ) ,			_lowercase   )




   def 			__a		(					self    :       Tuple ,			_lowercase    :       Any   ):



     """simple docstring"""






     self.insert_nth(0 ,			_lowercase   )




   def 			__a		(					self    :       Tuple ,			_lowercase    :       int ,			_lowercase    :       Any   ):



     """simple docstring"""






     if index < 0 or index > len(self   ):
       raise IndexError("""list index out of range."""   )
     SCREAMING_SNAKE_CASE__    							=   Node(_lowercase   )
     if self.head is None:
       SCREAMING_SNAKE_CASE__    							=   new_node  # first node points itself
       SCREAMING_SNAKE_CASE__    							=   SCREAMING_SNAKE_CASE__    							=   new_node
     elif index == 0:  # insert at head
       SCREAMING_SNAKE_CASE__    							=   self.head
       SCREAMING_SNAKE_CASE__    							=   SCREAMING_SNAKE_CASE__    							=   new_node
     else:
       SCREAMING_SNAKE_CASE__    							=   self.head
       for _ in range(index - 1   ):
         SCREAMING_SNAKE_CASE__    							=   temp.next
       SCREAMING_SNAKE_CASE__    							=   temp.next
       SCREAMING_SNAKE_CASE__    							=   new_node
       if index == len(self   ) - 1:  # insert at tail
         SCREAMING_SNAKE_CASE__    							=   new_node




   def 			__a		(					self    :       Dict   ):



     """simple docstring"""






     return self.delete_nth(0   )




   def 			__a		(					self    :       str   ):



     """simple docstring"""






     return self.delete_nth(len(self   ) - 1   )




   def 			__a		(					self    :       str ,			_lowercase    :       int = 0   ):



     """simple docstring"""






     if not 0 <= index < len(self   ):
       raise IndexError("""list index out of range."""   )
     SCREAMING_SNAKE_CASE__    							=   self.head
     if self.head == self.tail:  # just one node
       SCREAMING_SNAKE_CASE__    							=   SCREAMING_SNAKE_CASE__    							=   None
     elif index == 0:  # delete head node
       SCREAMING_SNAKE_CASE__    							=   self.tail.next.next
       SCREAMING_SNAKE_CASE__    							=   self.head.next
     else:
       SCREAMING_SNAKE_CASE__    							=   self.head
       for _ in range(index - 1   ):
         SCREAMING_SNAKE_CASE__    							=   temp.next
       SCREAMING_SNAKE_CASE__    							=   temp.next
       SCREAMING_SNAKE_CASE__    							=   temp.next.next
       if index == len(self   ) - 1:  # delete at tail
         SCREAMING_SNAKE_CASE__    							=   temp
     return delete_node.data




   def 			__a		(					self    :       Optional[int]   ):



     """simple docstring"""






     return len(self   ) == 0





def 			__SCREAMING_SNAKE_CASE						(      )							->      None:







  """simple docstring"""





  SCREAMING_SNAKE_CASE__    							=   CircularLinkedList()
  assert len(__UpperCamelCase			) == 0
  assert circular_linked_list.is_empty() is True
  assert str(__UpperCamelCase			) == ""

  try:
    circular_linked_list.delete_front()
    raise AssertionError  # This should not happen
  except IndexError:
    assert True  # This should happen

  try:
    circular_linked_list.delete_tail()
    raise AssertionError  # This should not happen
  except IndexError:
    assert True  # This should happen

  try:
    circular_linked_list.delete_nth(-1			)
    raise AssertionError
  except IndexError:
    assert True

  try:
    circular_linked_list.delete_nth(0			)
    raise AssertionError
  except IndexError:
    assert True

  assert circular_linked_list.is_empty() is True
  for i in range(5			):
    assert len(__UpperCamelCase			) == i
    circular_linked_list.insert_nth(__UpperCamelCase				,  i + 1			)
  assert str(__UpperCamelCase			) == "->".join(str(__UpperCamelCase			) for i in range(1				,  6			)			)

  circular_linked_list.insert_tail(6			)
  assert str(__UpperCamelCase			) == "->".join(str(__UpperCamelCase			) for i in range(1				,  7			)			)
  circular_linked_list.insert_head(0			)
  assert str(__UpperCamelCase			) == "->".join(str(__UpperCamelCase			) for i in range(0				,  7			)			)

  assert circular_linked_list.delete_front() == 0
  assert circular_linked_list.delete_tail() == 6
  assert str(__UpperCamelCase			) == "->".join(str(__UpperCamelCase			) for i in range(1				,  6			)			)
  assert circular_linked_list.delete_nth(2			) == 3

  circular_linked_list.insert_nth(2				,  3			)
  assert str(__UpperCamelCase			) == "->".join(str(__UpperCamelCase			) for i in range(1				,  6			)			)

  assert circular_linked_list.is_empty() is False


if __name__ == "__main__":
   import doctest

   doctest.testmod()
