



import gc
import unittest

import numpy as np
import torch

from diffusers import (
    AudioDiffusionPipeline,
    AutoencoderKL,
    DDIMScheduler,
    DDPMScheduler,
    DiffusionPipeline,
    Mel,
    UNetaDConditionModel,
    UNetaDModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()







class     __lowerCAmelCase					(    unittest.TestCase		):



			def 					_lowerCamelCase (		self     :						Dict)     ->					Any:



						"""simple docstring"""






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



			@property
			def 					_lowerCamelCase (		self     :						List[Any])     ->					str:



						"""simple docstring"""






						torch.manual_seed(0)
						_UpperCAmelCase	 =     UNetaDModel(
						    sample_size=(32, 64)				,	in_channels=1				,	out_channels=1				,	layers_per_block=2				,	block_out_channels=(1_28, 1_28)				,	down_block_types=('AttnDownBlock2D', 'DownBlock2D')				,	up_block_types=('UpBlock2D', 'AttnUpBlock2D')				,	)
						return model



			@property
			def 					_lowerCamelCase (		self     :						Union[str, Any])     ->					Any:



						"""simple docstring"""






						torch.manual_seed(0)
						_UpperCAmelCase	 =     UNetaDConditionModel(
						    sample_size=(64, 32)				,	in_channels=1				,	out_channels=1				,	layers_per_block=2				,	block_out_channels=(1_28, 1_28)				,	down_block_types=('CrossAttnDownBlock2D', 'DownBlock2D')				,	up_block_types=('UpBlock2D', 'CrossAttnUpBlock2D')				,	cross_attention_dim=10				,	)
						return model



			@property
			def 					_lowerCamelCase (		self     :						Union[str, Any])     ->					Tuple:



						"""simple docstring"""






						torch.manual_seed(0)
						_UpperCAmelCase	 =     AutoencoderKL(
						    sample_size=(1_28, 64)				,	in_channels=1				,	out_channels=1				,	latent_channels=1				,	layers_per_block=2				,	block_out_channels=(1_28, 1_28)				,	down_block_types=('DownEncoderBlock2D', 'DownEncoderBlock2D')				,	up_block_types=('UpDecoderBlock2D', 'UpDecoderBlock2D')				,	)
						_UpperCAmelCase	 =     UNetaDModel(
						    sample_size=(64, 32)				,	in_channels=1				,	out_channels=1				,	layers_per_block=2				,	block_out_channels=(1_28, 1_28)				,	down_block_types=('AttnDownBlock2D', 'DownBlock2D')				,	up_block_types=('UpBlock2D', 'AttnUpBlock2D')				,	)
						return vqvae, unet



			@slow
			def 					_lowerCamelCase (		self     :						str)     ->					Optional[int]:



						"""simple docstring"""






						_UpperCAmelCase	 =     'cpu'  # ensure determinism for the device-dependent torch.Generator
						_UpperCAmelCase	 =     Mel(
						    x_res=self.dummy_unet.config.sample_size[1]				,	y_res=self.dummy_unet.config.sample_size[0]				,	)

						_UpperCAmelCase	 =     DDPMScheduler()
						_UpperCAmelCase	 =     AudioDiffusionPipeline(vqvae=A				,	unet=self.dummy_unet				,	mel=A				,	scheduler=A)
						_UpperCAmelCase	 =     pipe.to(A)
						pipe.set_progress_bar_config(disable=A)

						_UpperCAmelCase	 =     torch.Generator(device=A).manual_seed(42)
						_UpperCAmelCase	 =     pipe(generator=A				,	steps=4)
						_UpperCAmelCase	 =     output.audios[0]
						_UpperCAmelCase	 =     output.images[0]

						_UpperCAmelCase	 =     torch.Generator(device=A).manual_seed(42)
						_UpperCAmelCase	 =     pipe(generator=A				,	steps=4				,	return_dict=A)
						_UpperCAmelCase	 =     output[0][0]

						assert audio.shape == (1, (self.dummy_unet.config.sample_size[1] - 1) * mel.hop_length)
						assert (
						    image.height == self.dummy_unet.config.sample_size[0]
						    and image.width == self.dummy_unet.config.sample_size[1]
						)
						_UpperCAmelCase	 =     np.frombuffer(image.tobytes()				,	dtype='uint8')[:10]
						_UpperCAmelCase	 =     np.frombuffer(image_from_tuple.tobytes()				,	dtype='uint8')[:10]
						_UpperCAmelCase	 =     np.array([69, 2_55, 2_55, 2_55, 0, 0, 77, 1_81, 12, 1_27])

						assert np.abs(image_slice.flatten() - expected_slice).max() == 0
						assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() == 0

						_UpperCAmelCase	 =     Mel(
						    x_res=self.dummy_vqvae_and_unet[0].config.sample_size[1]				,	y_res=self.dummy_vqvae_and_unet[0].config.sample_size[0]				,	)

						_UpperCAmelCase	 =     DDIMScheduler()
						_UpperCAmelCase	 =     self.dummy_vqvae_and_unet
						_UpperCAmelCase	 =     AudioDiffusionPipeline(
						    vqvae=self.dummy_vqvae_and_unet[0]				,	unet=dummy_vqvae_and_unet[1]				,	mel=A				,	scheduler=A)
						_UpperCAmelCase	 =     pipe.to(A)
						pipe.set_progress_bar_config(disable=A)

						np.random.seed(0)
						_UpperCAmelCase	 =     np.random.uniform(-1				,	1				,	((dummy_vqvae_and_unet[0].config.sample_size[1] - 1) * mel.hop_length,))
						_UpperCAmelCase	 =     torch.Generator(device=A).manual_seed(42)
						_UpperCAmelCase	 =     pipe(raw_audio=A				,	generator=A				,	start_step=5				,	steps=10)
						_UpperCAmelCase	 =     output.images[0]

						assert (
						    image.height == self.dummy_vqvae_and_unet[0].config.sample_size[0]
						    and image.width == self.dummy_vqvae_and_unet[0].config.sample_size[1]
						)
						_UpperCAmelCase	 =     np.frombuffer(image.tobytes()				,	dtype='uint8')[:10]
						_UpperCAmelCase	 =     np.array([1_20, 1_17, 1_10, 1_09, 1_38, 1_67, 1_38, 1_48, 1_32, 1_21])

						assert np.abs(image_slice.flatten() - expected_slice).max() == 0

						_UpperCAmelCase	 =     self.dummy_unet_condition
						_UpperCAmelCase	 =     AudioDiffusionPipeline(
						    vqvae=self.dummy_vqvae_and_unet[0]				,	unet=A				,	mel=A				,	scheduler=A)
						_UpperCAmelCase	 =     pipe.to(A)
						pipe.set_progress_bar_config(disable=A)

						np.random.seed(0)
						_UpperCAmelCase	 =     torch.rand((1, 1, 10))
						_UpperCAmelCase	 =     pipe(generator=A				,	encoding=A)
						_UpperCAmelCase	 =     output.images[0]
						_UpperCAmelCase	 =     np.frombuffer(image.tobytes()				,	dtype='uint8')[:10]
						_UpperCAmelCase	 =     np.array([1_07, 1_03, 1_20, 1_27, 1_42, 1_22, 1_13, 1_22, 97, 1_11])

						assert np.abs(image_slice.flatten() - expected_slice).max() == 0







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



			def 					_lowerCamelCase (		self     :						int)     ->					Union[str, Any]:



						"""simple docstring"""






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



			def 					_lowerCamelCase (		self     :						Optional[Any])     ->					List[str]:



						"""simple docstring"""






						_UpperCAmelCase	 =     torch_device

						_UpperCAmelCase	 =     DiffusionPipeline.from_pretrained('teticio/audio-diffusion-ddim-256')
						_UpperCAmelCase	 =     pipe.to(A)
						pipe.set_progress_bar_config(disable=A)

						_UpperCAmelCase	 =     torch.Generator(device=A).manual_seed(42)
						_UpperCAmelCase	 =     pipe(generator=A)
						_UpperCAmelCase	 =     output.audios[0]
						_UpperCAmelCase	 =     output.images[0]

						assert audio.shape == (1, (pipe.unet.config.sample_size[1] - 1) * pipe.mel.hop_length)
						assert image.height == pipe.unet.config.sample_size[0] and image.width == pipe.unet.config.sample_size[1]
						_UpperCAmelCase	 =     np.frombuffer(image.tobytes()				,	dtype='uint8')[:10]
						_UpperCAmelCase	 =     np.array([1_51, 1_67, 1_54, 1_44, 1_22, 1_34, 1_21, 1_05, 70, 26])

						assert np.abs(image_slice.flatten() - expected_slice).max() == 0





import os

# Precomputes a list of the 100 first triangular numbers
UpperCAmelCase__     = [int(0.5 * n * (n + 1)) for n in range(1, 101)]





def 							A			(  )       ->				List[str]:







			'''simple docstring'''
			_UpperCAmelCase	 =     os.path.dirname(os.path.realpath(_UpperCAmelCase					)					)
			_UpperCAmelCase	 =     os.path.join(_UpperCAmelCase							,     'words.txt'					)

			_UpperCAmelCase	 =     ''
			with open(_UpperCAmelCase					) as f:
						_UpperCAmelCase	 =     f.readline()

			_UpperCAmelCase	 =     [word.strip('"'					) for word in words.strip('\r\n'					).split(','					)]
			_UpperCAmelCase	 =     [
			    word
			    for word in [sum(ord(_UpperCAmelCase					) - 64 for x in word					) for word in words]
			    if word in TRIANGULAR_NUMBERS
			]
			return len(_UpperCAmelCase					)


if __name__ == "__main__":
							print(solution())
