





import gc
import unittest

import numpy as np
import torch

from diffusers import DanceDiffusionPipeline, IPNDMScheduler, UNetaDModel
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

from ..pipeline_params import UNCONDITIONAL_AUDIO_GENERATION_BATCH_PARAMS, UNCONDITIONAL_AUDIO_GENERATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()



class 							_UpperCAmelCase       (       _UpperCamelCase						,       unittest.TestCase       ):

  """simple docstring"""


  a_              =					DanceDiffusionPipeline
  a_              =					UNCONDITIONAL_AUDIO_GENERATION_PARAMS
  a_              =					PipelineTesterMixin.required_optional_params - {
      """callback""",
      """latents""",
      """callback_steps""",
      """output_type""",
      """num_images_per_prompt""",
  }
  a_              =					UNCONDITIONAL_AUDIO_GENERATION_BATCH_PARAMS
  a_              =					False
  a_              =					False






  def 							lowercase						(							self					:						int	)				->		Union[str, Any]:
     torch.manual_seed(0	)
     __lowerCAmelCase				      =      UNetaDModel(
         block_out_channels=(3_2, 3_2, 6_4)   ,    extra_in_channels=1_6   ,    sample_size=5_1_2   ,    sample_rate=1_6_0_0_0   ,    in_channels=2   ,    out_channels=2   ,    flip_sin_to_cos=lowerCAmelCase_   ,    use_timestep_embedding=lowerCAmelCase_   ,    time_embedding_type='fourier'   ,    mid_block_type='UNetMidBlock1D'   ,    down_block_types=('DownBlock1DNoSkip', 'DownBlock1D', 'AttnDownBlock1D')   ,    up_block_types=('AttnUpBlock1D', 'UpBlock1D', 'UpBlock1DNoSkip')   ,    )
     __lowerCAmelCase				      =      IPNDMScheduler()

     __lowerCAmelCase				      =      {
         'unet': unet,
         'scheduler': scheduler,
     }
     return components






  def 							lowercase						(							self					:						Union[str, Any]   ,    lowerCAmelCase_					:						Dict   ,    lowerCAmelCase_					:						Union[str, Any]=0	)				->		int:
     if str(lowerCAmelCase_	).startswith('mps'	):
        __lowerCAmelCase				      =      torch.manual_seed(lowerCAmelCase_	)
     else:
        __lowerCAmelCase				      =      torch.Generator(device=lowerCAmelCase_	).manual_seed(lowerCAmelCase_	)
     __lowerCAmelCase				      =      {
         'batch_size': 1,
         'generator': generator,
         'num_inference_steps': 4,
     }
     return inputs






  def 							lowercase						(							self					:						List[Any]	)				->		Dict:
     __lowerCAmelCase				      =      'cpu'  # ensure determinism for the device-dependent torch.Generator
     __lowerCAmelCase				      =      self.get_dummy_components()
     __lowerCAmelCase				      =      DanceDiffusionPipeline(**lowerCAmelCase_	)
     __lowerCAmelCase				      =      pipe.to(lowerCAmelCase_	)
     pipe.set_progress_bar_config(disable=lowerCAmelCase_	)

     __lowerCAmelCase				      =      self.get_dummy_inputs(lowerCAmelCase_	)
     __lowerCAmelCase				      =      pipe(**lowerCAmelCase_	)
     __lowerCAmelCase				      =      output.audios

     __lowerCAmelCase				      =      audio[0, -3:, -3:]

     assert audio.shape == (1, 2, components["unet"].sample_size)
     __lowerCAmelCase				      =      np.array([-0.72_65, 1.00_00, -0.83_88, 0.11_75, 0.94_98, -1.00_00]	)
     assert np.abs(audio_slice.flatten() - expected_slice	).max() < 1e-2






  @skip_mps
  def 							lowercase						(							self					:						Any	)				->		Any:
     return super().test_save_load_local()






  @skip_mps
  def 							lowercase						(							self					:						Union[str, Any]	)				->		Union[str, Any]:
     return super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3	)






  @skip_mps
  def 							lowercase						(							self					:						Optional[int]	)				->		Dict:
     return super().test_save_load_optional_components()






  @skip_mps
  def 							lowercase						(							self					:						Tuple	)				->		Any:
     return super().test_attention_slicing_forward_pass()






  def 							lowercase						(							self					:						str	)				->		Union[str, Any]:
     super().test_inference_batch_single_identical(expected_max_diff=3e-3	)





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

  """simple docstring"""


  def 							lowercase						(							self					:						Optional[int]	)				->		Optional[Any]:
     # clean up the VRAM after each test
     super().tearDown()
     gc.collect()
     torch.cuda.empty_cache()






  def 							lowercase						(							self					:						int	)				->		Dict:
     __lowerCAmelCase				      =      torch_device

     __lowerCAmelCase				      =      DanceDiffusionPipeline.from_pretrained('harmonai/maestro-150k'	)
     __lowerCAmelCase				      =      pipe.to(lowerCAmelCase_	)
     pipe.set_progress_bar_config(disable=lowerCAmelCase_	)

     __lowerCAmelCase				      =      torch.manual_seed(0	)
     __lowerCAmelCase				      =      pipe(generator=lowerCAmelCase_   ,    num_inference_steps=1_0_0   ,    audio_length_in_s=4.0_96	)
     __lowerCAmelCase				      =      output.audios

     __lowerCAmelCase				      =      audio[0, -3:, -3:]

     assert audio.shape == (1, 2, pipe.unet.sample_size)
     __lowerCAmelCase				      =      np.array([-0.01_92, -0.02_31, -0.03_18, -0.00_59, 0.00_02, -0.00_20]	)

     assert np.abs(audio_slice.flatten() - expected_slice	).max() < 1e-2






  def 							lowercase						(							self					:						Tuple	)				->		Optional[int]:
     __lowerCAmelCase				      =      torch_device

     __lowerCAmelCase				      =      DanceDiffusionPipeline.from_pretrained('harmonai/maestro-150k'   ,    torch_dtype=torch.floataa	)
     __lowerCAmelCase				      =      pipe.to(lowerCAmelCase_	)
     pipe.set_progress_bar_config(disable=lowerCAmelCase_	)

     __lowerCAmelCase				      =      torch.manual_seed(0	)
     __lowerCAmelCase				      =      pipe(generator=lowerCAmelCase_   ,    num_inference_steps=1_0_0   ,    audio_length_in_s=4.0_96	)
     __lowerCAmelCase				      =      output.audios

     __lowerCAmelCase				      =      audio[0, -3:, -3:]

     assert audio.shape == (1, 2, pipe.unet.sample_size)
     __lowerCAmelCase				      =      np.array([-0.03_67, -0.04_88, -0.07_71, -0.05_25, -0.04_44, -0.03_41]	)

     assert np.abs(audio_slice.flatten() - expected_slice	).max() < 1e-2








'''simple docstring'''




import cmath
import math




def 						__lowerCamelCase			(	UpperCAmelCase_					,				UpperCAmelCase_					,				UpperCAmelCase_					,				UpperCAmelCase_							)   ->complex:
	snake_case__	       =   math.radians(UpperCAmelCase_							)
	snake_case__	       =   math.radians(UpperCAmelCase_							)

	# Convert voltage and current to rectangular form
	snake_case__	       =   cmath.rect(UpperCAmelCase_					,				UpperCAmelCase_							)
	snake_case__	       =   cmath.rect(UpperCAmelCase_					,				UpperCAmelCase_							)

	# Calculate apparent power
	return voltage_rect * current_rect


if __name__ == "__main__":
			import doctest

			doctest.testmod()



