





from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching





def 		__SCREAMING_SNAKE_CASE    (							)    ->							Dict:







			'''simple docstring'''

			import os as original_os
			from os import path as original_path
			from os import rename as original_rename
			from os.path import dirname as original_dirname
			from os.path import join as original_join

			assert _test_patching.os is original_os
			assert _test_patching.path is original_path
			assert _test_patching.join is original_join

			assert _test_patching.renamed_os is original_os
			assert _test_patching.renamed_path is original_path
			assert _test_patching.renamed_join is original_join

			UpperCAmelCase  						=							'''__test_patch_submodule_mock__'''
			with patch_submodule(_test_patching     ,     '''os.path.join'''     ,     SCREAMING_SNAKE_CASE_					):
						# Every way to access os.path.join must be patched, and the rest must stay untouched

						# check os.path.join
						assert isinstance(_test_patching.os     ,     _PatchedModuleObj					)
						assert isinstance(_test_patching.os.path     ,     _PatchedModuleObj					)
						assert _test_patching.os.path.join is mock

						# check path.join
						assert isinstance(_test_patching.path     ,     _PatchedModuleObj					)
						assert _test_patching.path.join is mock

						# check join
						assert _test_patching.join is mock

						# check that the other attributes are untouched
						assert _test_patching.os.rename is original_rename
						assert _test_patching.path.dirname is original_dirname
						assert _test_patching.os.path.dirname is original_dirname

						# Even renamed modules or objects must be patched

						# check renamed_os.path.join
						assert isinstance(_test_patching.renamed_os     ,     _PatchedModuleObj					)
						assert isinstance(_test_patching.renamed_os.path     ,     _PatchedModuleObj					)
						assert _test_patching.renamed_os.path.join is mock

						# check renamed_path.join
						assert isinstance(_test_patching.renamed_path     ,     _PatchedModuleObj					)
						assert _test_patching.renamed_path.join is mock

						# check renamed_join
						assert _test_patching.renamed_join is mock

						# check that the other attributes are untouched
						assert _test_patching.renamed_os.rename is original_rename
						assert _test_patching.renamed_path.dirname is original_dirname
						assert _test_patching.renamed_os.path.dirname is original_dirname

			# check that everthing is back to normal when the patch is over

			assert _test_patching.os is original_os
			assert _test_patching.path is original_path
			assert _test_patching.join is original_join

			assert _test_patching.renamed_os is original_os
			assert _test_patching.renamed_path is original_path
			assert _test_patching.renamed_join is original_join





def 		__SCREAMING_SNAKE_CASE    (							)    ->							Dict:







			'''simple docstring'''

			assert _test_patching.open is open

			UpperCAmelCase  						=							'''__test_patch_submodule_builtin_mock__'''
			# _test_patching has "open" in its globals
			assert _test_patching.open is open
			with patch_submodule(_test_patching     ,     '''open'''     ,     SCREAMING_SNAKE_CASE_					):
						assert _test_patching.open is mock

			# check that everthing is back to normal when the patch is over

			assert _test_patching.open is open





def 		__SCREAMING_SNAKE_CASE    (							)    ->							List[Any]:







			'''simple docstring'''

			UpperCAmelCase  						=							'''__test_patch_submodule_missing_mock__'''
			with patch_submodule(_test_patching     ,     '''pandas.read_csv'''     ,     SCREAMING_SNAKE_CASE_					):
						pass





def 		__SCREAMING_SNAKE_CASE    (							)    ->							List[Any]:







			'''simple docstring'''

			UpperCAmelCase  						=							'''__test_patch_submodule_missing_builtin_mock__'''
			# _test_patching doesn't have "len" in its globals
			assert getattr(_test_patching     ,     '''len'''     ,     SCREAMING_SNAKE_CASE_					) is None
			with patch_submodule(_test_patching     ,     '''len'''     ,     SCREAMING_SNAKE_CASE_					):
						assert _test_patching.len is mock
			assert _test_patching.len is len





def 		__SCREAMING_SNAKE_CASE    (							)    ->							Tuple:







			'''simple docstring'''

			UpperCAmelCase  						=							'''__test_patch_submodule_start_and_stop_mock__'''
			UpperCAmelCase  						=							patch_submodule(_test_patching     ,     '''open'''     ,     SCREAMING_SNAKE_CASE_					)
			assert _test_patching.open is open
			patch.start()
			assert _test_patching.open is mock
			patch.stop()
			assert _test_patching.open is open





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







			'''simple docstring'''

			from os import rename as original_rename
			from os.path import dirname as original_dirname
			from os.path import join as original_join

			UpperCAmelCase  						=							'''__test_patch_submodule_successive_join__'''
			UpperCAmelCase  						=							'''__test_patch_submodule_successive_dirname__'''
			UpperCAmelCase  						=							'''__test_patch_submodule_successive_rename__'''
			assert _test_patching.os.path.join is original_join
			assert _test_patching.os.path.dirname is original_dirname
			assert _test_patching.os.rename is original_rename

			with patch_submodule(_test_patching     ,     '''os.path.join'''     ,     SCREAMING_SNAKE_CASE_					):
						with patch_submodule(_test_patching     ,     '''os.rename'''     ,     SCREAMING_SNAKE_CASE_					):
									with patch_submodule(_test_patching     ,     '''os.path.dirname'''     ,     SCREAMING_SNAKE_CASE_					):
												assert _test_patching.os.path.join is mock_join
												assert _test_patching.os.path.dirname is mock_dirname
												assert _test_patching.os.rename is mock_rename

    # try another order
			with patch_submodule(_test_patching     ,     '''os.rename'''     ,     SCREAMING_SNAKE_CASE_					):
						with patch_submodule(_test_patching     ,     '''os.path.join'''     ,     SCREAMING_SNAKE_CASE_					):
									with patch_submodule(_test_patching     ,     '''os.path.dirname'''     ,     SCREAMING_SNAKE_CASE_					):
												assert _test_patching.os.path.join is mock_join
												assert _test_patching.os.path.dirname is mock_dirname
												assert _test_patching.os.rename is mock_rename

			assert _test_patching.os.path.join is original_join
			assert _test_patching.os.path.dirname is original_dirname
			assert _test_patching.os.rename is original_rename






def 		__SCREAMING_SNAKE_CASE    (							)    ->							List[Any]:







			'''simple docstring'''

			UpperCAmelCase  						=							'''__test_patch_submodule_doesnt_exist_mock__'''
			with patch_submodule(_test_patching     ,     '''__module_that_doesn_exist__.__attribute_that_doesn_exist__'''     ,     SCREAMING_SNAKE_CASE_					):
						pass
			with patch_submodule(_test_patching     ,     '''os.__attribute_that_doesn_exist__'''     ,     SCREAMING_SNAKE_CASE_					):
						pass










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    (							A__	, unittest.TestCase    ):
     __A	:  Any							  =   DanceDiffusionPipeline
     __A	:  Any							  =   UNCONDITIONAL_AUDIO_GENERATION_PARAMS
     __A	:  Tuple							  =   PipelineTesterMixin.required_optional_params - {
         """callback""",
         """latents""",
         """callback_steps""",
         """output_type""",
         """num_images_per_prompt""",
     }
     __A	:  Tuple							  =   UNCONDITIONAL_AUDIO_GENERATION_BATCH_PARAMS
     __A	:  List[str]							  =   False
     __A	:  str							  =   False





     def 		UpperCamelCase(     self					):
        torch.manual_seed(0					)
        _UpperCAmelCase           =   UNetaDModel(
            block_out_channels=(32, 32, 64)				,							extra_in_channels=16				,							sample_size=512				,							sample_rate=16000				,							in_channels=2				,							out_channels=2				,							flip_sin_to_cos=_UpperCamelCase				,							use_timestep_embedding=_UpperCamelCase				,							time_embedding_type='''fourier'''				,							mid_block_type='''UNetMidBlock1D'''				,							down_block_types=('''DownBlock1DNoSkip''', '''DownBlock1D''', '''AttnDownBlock1D''')				,							up_block_types=('''AttnUpBlock1D''', '''UpBlock1D''', '''UpBlock1DNoSkip''')				,							)
        _UpperCAmelCase           =   IPNDMScheduler()

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





     def 		UpperCamelCase(     self				,							_UpperCamelCase				,							_UpperCamelCase=0					):
        if str(_UpperCamelCase					).startswith('''mps'''					):
           _UpperCAmelCase           =   torch.manual_seed(_UpperCamelCase					)
        else:
           _UpperCAmelCase           =   torch.Generator(device=_UpperCamelCase					).manual_seed(_UpperCamelCase					)
        _UpperCAmelCase           =   {
            '''batch_size''': 1,
            '''generator''': generator,
            '''num_inference_steps''': 4,
        }
        return inputs





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   '''cpu'''  # ensure determinism for the device-dependent torch.Generator
        _UpperCAmelCase           =   self.get_dummy_components()
        _UpperCAmelCase           =   DanceDiffusionPipeline(**_UpperCamelCase					)
        _UpperCAmelCase           =   pipe.to(_UpperCamelCase					)
        pipe.set_progress_bar_config(disable=_UpperCamelCase					)

        _UpperCAmelCase           =   self.get_dummy_inputs(_UpperCamelCase					)
        _UpperCAmelCase           =   pipe(**_UpperCamelCase					)
        _UpperCAmelCase           =   output.audios

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

        assert audio.shape == (1, 2, components["unet"].sample_size)
        _UpperCAmelCase           =   np.array([-0.7265, 1.0000, -0.8388, 0.1175, 0.9498, -1.0000]					)
        assert np.abs(audio_slice.flatten() - expected_slice					).max() < 1e-2





     @skip_mps
     def 		UpperCamelCase(     self					):
        return super().test_save_load_local()





     @skip_mps
     def 		UpperCamelCase(     self					):
        return super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3					)





     @skip_mps
     def 		UpperCamelCase(     self					):
        return super().test_save_load_optional_components()





     @skip_mps
     def 		UpperCamelCase(     self					):
        return super().test_attention_slicing_forward_pass()





     def 		UpperCamelCase(     self					):
        super().test_inference_batch_single_identical(expected_max_diff=3e-3					)




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





     def 		UpperCamelCase(     self					):
        # clean up the VRAM after each test
        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   torch_device

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

        _UpperCAmelCase           =   torch.manual_seed(0					)
        _UpperCAmelCase           =   pipe(generator=_UpperCamelCase				,							num_inference_steps=100				,							audio_length_in_s=4.096					)
        _UpperCAmelCase           =   output.audios

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

        assert audio.shape == (1, 2, pipe.unet.sample_size)
        _UpperCAmelCase           =   np.array([-0.0192, -0.0231, -0.0318, -0.0059, 0.0002, -0.0020]					)

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





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   torch_device

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

        _UpperCAmelCase           =   torch.manual_seed(0					)
        _UpperCAmelCase           =   pipe(generator=_UpperCamelCase				,							num_inference_steps=100				,							audio_length_in_s=4.096					)
        _UpperCAmelCase           =   output.audios

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

        assert audio.shape == (1, 2, pipe.unet.sample_size)
        _UpperCAmelCase           =   np.array([-0.0367, -0.0488, -0.0771, -0.0525, -0.0444, -0.0341]					)

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