




'''simple docstring'''







import numpy as np
from cva import COLOR_BGR2GRAY, cvtColor, imread
from numpy import array, uinta
from PIL import Image

from digital_image_processing import change_contrast as cc
from digital_image_processing import convert_to_negative as cn
from digital_image_processing import sepia as sp
from digital_image_processing.dithering import burkes as bs
from digital_image_processing.edge_detection import canny
from digital_image_processing.filters import convolve as conv
from digital_image_processing.filters import gaussian_filter as gg
from digital_image_processing.filters import local_binary_pattern as lbp
from digital_image_processing.filters import median_filter as med
from digital_image_processing.filters import sobel_filter as sob
from digital_image_processing.resize import resize as rs

lowercase      :   Any      =       imread(R"""digital_image_processing/image_data/lena_small.jpg""")
lowercase      :   List[str]      =       cvtColor(img, COLOR_BGR2GRAY)



def        lowerCamelCase__				(      ):
     snake_case			:      Optional[int]        =			cn.convert_to_negative(__lowercase				)
     # assert negative_img array for at least one True
     assert negative_img.any()



def        lowerCamelCase__				(      ):
     with Image.open("""digital_image_processing/image_data/lena_small.jpg"""				) as img:
          # Work around assertion for response
          assert str(cc.change_contrast(__lowercase     ,   110				)				).startswith(
              """<PIL.Image.Image image mode=RGB size=100x100 at"""				)



def        lowerCamelCase__				(      ):
     snake_case			:      Union[str, Any]        =			canny.gen_gaussian_kernel(9     ,   sigma=1.4				)
     # Assert ambiguous array
     assert resp.all()



def        lowerCamelCase__				(      ):
     snake_case			:      Optional[Any]        =			imread("""digital_image_processing/image_data/lena_small.jpg"""     ,   0				)
     # assert ambiguous array for all == True
     assert canny_img.all()
     snake_case			:      Any        =			canny.canny(__lowercase				)
     # assert canny array for at least one True
     assert canny_array.any()



def        lowerCamelCase__				(      ):
     assert gg.gaussian_filter(__lowercase     ,   5     ,   sigma=0.9				).all()



def        lowerCamelCase__				(      ):
     # laplace diagonals
     snake_case			:      int        =			array([[0.25, 0.5, 0.25], [0.5, -3, 0.5], [0.25, 0.5, 0.25]]				)
     snake_case			:      Tuple        =			conv.img_convolve(__lowercase     ,   __lowercase				).astype(__lowercase				)
     assert res.any()



def        lowerCamelCase__				(      ):
     assert med.median_filter(__lowercase     ,   3				).any()



def        lowerCamelCase__				(      ):
     snake_case ,		snake_case			:      Dict        =			sob.sobel_filter(__lowercase				)
     assert grad.any() and theta.any()



def        lowerCamelCase__				(      ):
     snake_case			:      int        =			sp.make_sepia(__lowercase     ,   20				)
     assert sepia.all()



def        lowerCamelCase__				(      __lowercase = "digital_image_processing/image_data/lena_small.jpg"				):
     snake_case			:      int        =			bs.Burkes(imread(__lowercase     ,   1				)     ,   120				)
     burkes.process()
     assert burkes.output_img.any()



def        lowerCamelCase__				(      __lowercase = "digital_image_processing/image_data/lena_small.jpg"     ,   ):
     snake_case			:      Dict        =			rs.NearestNeighbour(imread(__lowercase     ,   1				)     ,   400     ,   200				)
     nn.process()
     assert nn.output.any()







def        lowerCamelCase__				(      ):
     snake_case			:      int        =			"""digital_image_processing/image_data/lena.jpg"""

     # Reading the image and converting it to grayscale.
     snake_case			:      Tuple        =			imread(__lowercase     ,   0				)

     # Test for get_neighbors_pixel function() return not None
     snake_case			:      Optional[int]        =			0
     snake_case			:      Tuple        =			0
     snake_case			:      Any        =			image[x_coordinate][y_coordinate]

     snake_case			:      Any        =			lbp.get_neighbors_pixel(
         __lowercase     ,   __lowercase     ,   __lowercase     ,   __lowercase				)

     assert neighbors_pixels is not None

     # Test for local_binary_pattern function()
     # Create a numpy array as the same height and width of read image
     snake_case			:      List[Any]        =			np.zeros((image.shape[0], image.shape[1])				)

     # Iterating through the image and calculating the local binary pattern value
     # for each pixel.
     for i in range(0     ,   image.shape[0]				):
          for j in range(0     ,   image.shape[1]				):
               snake_case			:      Optional[Any]        =			lbp.local_binary_value(__lowercase     ,   __lowercase     ,   __lowercase				)

     assert lbp_image.any()









'''simple docstring'''







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 					_a (a__,		unittest.TestCase	):





     '''simple docstring'''



     lowerCAmelCase_  :     Dict          =					DanceDiffusionPipeline
     lowerCAmelCase_  :     int          =					UNCONDITIONAL_AUDIO_GENERATION_PARAMS
     lowerCAmelCase_  :     Optional[int]          =					PipelineTesterMixin.required_optional_params - {
         """callback""",
         """latents""",
         """callback_steps""",
         """output_type""",
         """num_images_per_prompt""",
     }
     lowerCAmelCase_  :     Tuple          =					UNCONDITIONAL_AUDIO_GENERATION_BATCH_PARAMS
     lowerCAmelCase_  :     Dict          =					False
     lowerCAmelCase_  :     Tuple          =					False







     def 			snake_case_      (				self							)      ->				List[Any]:
          torch.manual_seed(0							)
          snake_case			:      List[str]        =			UNetaDModel(
              block_out_channels=(32, 32, 64)							,extra_in_channels=16							,sample_size=512							,sample_rate=16_000							,in_channels=2							,out_channels=2							,flip_sin_to_cos=__a							,use_timestep_embedding=__a							,time_embedding_type="""fourier"""							,mid_block_type="""UNetMidBlock1D"""							,down_block_types=("""DownBlock1DNoSkip""", """DownBlock1D""", """AttnDownBlock1D""")							,up_block_types=("""AttnUpBlock1D""", """UpBlock1D""", """UpBlock1DNoSkip""")							,)
          snake_case			:      Dict        =			IPNDMScheduler()

          snake_case			:      int        =			{
              """unet""": unet,
              """scheduler""": scheduler,
          }
          return components







     def 			snake_case_      (				self							,__a							,__a=0							)      ->				Tuple:
          if str(__a							).startswith("""mps"""							):
               snake_case			:      Optional[Any]        =			torch.manual_seed(__a							)
          else:
               snake_case			:      Union[str, Any]        =			torch.Generator(device=__a							).manual_seed(__a							)
          snake_case			:      str        =			{
              """batch_size""": 1,
              """generator""": generator,
              """num_inference_steps""": 4,
          }
          return inputs







     def 			snake_case_      (				self							)      ->				Any:
          snake_case			:      Dict        =			"""cpu"""  # ensure determinism for the device-dependent torch.Generator
          snake_case			:      str        =			self.get_dummy_components()
          snake_case			:      List[str]        =			DanceDiffusionPipeline(**__a							)
          snake_case			:      Dict        =			pipe.to(__a							)
          pipe.set_progress_bar_config(disable=__a							)

          snake_case			:      Union[str, Any]        =			self.get_dummy_inputs(__a							)
          snake_case			:      str        =			pipe(**__a							)
          snake_case			:      Union[str, Any]        =			output.audios

          snake_case			:      List[str]        =			audio[0, -3:, -3:]

          assert audio.shape == (1, 2, components["unet"].sample_size)
          snake_case			:      Optional[Any]        =			np.array([-0.7_265, 1.0_000, -0.8_388, 0.1_175, 0.9_498, -1.0_000]							)
          assert np.abs(audio_slice.flatten() - expected_slice							).max() < 1E-2







     @skip_mps
     def 			snake_case_      (				self							)      ->				List[str]:
          return super().test_save_load_local()







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







     @skip_mps
     def 			snake_case_      (				self							)      ->				Dict:
          return super().test_save_load_optional_components()







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







     def 			snake_case_      (				self							)      ->				str:
          super().test_inference_batch_single_identical(expected_max_diff=3E-3							)







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





     '''simple docstring'''



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







     def 			snake_case_      (				self							)      ->				List[Any]:
          snake_case			:      str        =			torch_device

          snake_case			:      List[str]        =			DanceDiffusionPipeline.from_pretrained("""harmonai/maestro-150k"""							)
          snake_case			:      Any        =			pipe.to(__a							)
          pipe.set_progress_bar_config(disable=__a							)

          snake_case			:      int        =			torch.manual_seed(0							)
          snake_case			:      int        =			pipe(generator=__a							,num_inference_steps=100							,audio_length_in_s=4.096							)
          snake_case			:      Dict        =			output.audios

          snake_case			:      Union[str, Any]        =			audio[0, -3:, -3:]

          assert audio.shape == (1, 2, pipe.unet.sample_size)
          snake_case			:      Tuple        =			np.array([-0.0_192, -0.0_231, -0.0_318, -0.0_059, 0.0_002, -0.0_020]							)

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







     def 			snake_case_      (				self							)      ->				str:
          snake_case			:      str        =			torch_device

          snake_case			:      List[Any]        =			DanceDiffusionPipeline.from_pretrained("""harmonai/maestro-150k"""							,torch_dtype=torch.floataa							)
          snake_case			:      str        =			pipe.to(__a							)
          pipe.set_progress_bar_config(disable=__a							)

          snake_case			:      str        =			torch.manual_seed(0							)
          snake_case			:      List[str]        =			pipe(generator=__a							,num_inference_steps=100							,audio_length_in_s=4.096							)
          snake_case			:      Optional[int]        =			output.audios

          snake_case			:      Any        =			audio[0, -3:, -3:]

          assert audio.shape == (1, 2, pipe.unet.sample_size)
          snake_case			:      Optional[int]        =			np.array([-0.0_367, -0.0_488, -0.0_771, -0.0_525, -0.0_444, -0.0_341]							)

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



