import os
from dataclasses import dataclass, field
from io import BytesIO
from typing import TYPE_CHECKING, Any, ClassVar, Dict, Optional, Union

import numpy as np
import pyarrow as pa

from .. import config
from ..download.streaming_download_manager import xopen, xsplitext
from ..table import array_cast
from ..utils.py_utils import no_op_if_value_is_null, string_to_dict


if TYPE_CHECKING:
		from .features import FeatureType


lowerCamelCase,       lowerCamelCase,       lowerCamelCase						=		False, False, False





@dataclass
class  _a							:
	_a  :  Optional[int]				   =							None
	_a  :  bool				   =							True
	_a  :  bool				   =							True
	_a  :  Optional[str]				   =							None
	# Automatically constructed
	_a  :  ClassVar[str]				   =							"dict"
	_a  :  ClassVar[Any]				   =							pa.struct({'''bytes''': pa.binary(), '''path''': pa.string()})
	_a  :  str				   =							field(default='''Audio'''					,						init=_lowercase					,						repr=_lowercase)




	def __call__( self						:		Tuple		)->	Optional[Any]:
			return self.pa_type




	def 							UpperCAmelCase__( self						:		str		, _SCREAMING_SNAKE_CASE						:		Union[str, bytes, dict]		)->	dict:




			try:
					import soundfile as sf  # soundfile is a dependency of librosa, needed to decode audio files.
			except ImportError as err:
					raise ImportError('''To support encoding audio data, please install \'soundfile\'.'''		) from err
			if isinstance(lowerCAmelCase__		, lowerCAmelCase__		):
					return {"bytes": None, "path": value}
			elif isinstance(lowerCAmelCase__		, lowerCAmelCase__		):
					return {"bytes": value, "path": None}
			elif "array" in value:
					# convert the audio array to wav bytes
					lowerCAmelCase__       :      Tuple   					= BytesIO()
					sf.write(lowerCAmelCase__		, value['''array''']		, value['''sampling_rate''']		, format='''wav'''		)
					return {"bytes": buffer.getvalue(), "path": None}
			elif value.get('''path'''		) is not None and os.path.isfile(value['''path''']		):
					# we set "bytes": None to not duplicate the data if they're already available locally
					if value["path"].endswith('''pcm'''		):
							# "PCM" only has raw audio bytes
							if value.get('''sampling_rate'''		) is None:
									# At least, If you want to convert "PCM-byte" to "WAV-byte", you have to know sampling rate
									raise KeyError('''To use PCM files, please specify a \'sampling_rate\' in Audio object'''		)
							if value.get('''bytes'''		):
									# If we already had PCM-byte, we don`t have to make "read file, make bytes" (just use it!)
									lowerCAmelCase__       :      Optional[Any]   					= np.frombuffer(value['''bytes''']		, dtype=np.intaa		).astype(np.floataa		) / 3_2767
							else:
									lowerCAmelCase__       :      Optional[int]   					= np.memmap(value['''path''']		, dtype='''h'''		, mode='''r'''		).astype(np.floataa		) / 3_2767

							lowerCAmelCase__       :      Any   					= BytesIO(bytes()		)
							sf.write(lowerCAmelCase__		, lowerCAmelCase__		, value['''sampling_rate''']		, format='''wav'''		)
							return {"bytes": buffer.getvalue(), "path": None}
					else:
							return {"bytes": None, "path": value.get('''path'''		)}
			elif value.get('''bytes'''		) is not None or value.get('''path'''		) is not None:
					# store the audio bytes, and path is used to infer the audio format using the file extension
					return {"bytes": value.get('''bytes'''		), "path": value.get('''path'''		)}
			else:
					raise ValueError(
					    F'An audio sample should have one of \'path\' or \'bytes\' but they are missing or None in {value}.'		)




	def 							UpperCAmelCase__( self						:		Optional[Any]		, _SCREAMING_SNAKE_CASE						:		dict		, _SCREAMING_SNAKE_CASE						:		Optional[Dict[str, Union[str, bool, None]]] = None		)->	dict:




			if not self.decode:
					raise RuntimeError('''Decoding is disabled for this feature. Please use Audio(decode=True) instead.'''		)

			lowerCAmelCase__       :      Optional[int]   					= (value["path"], BytesIO(value['''bytes''']		)) if value["bytes"] is not None else (value["path"], None)
			if path is None and file is None:
					raise ValueError(F'An audio sample should have one of \'path\' or \'bytes\' but both are None in {value}.'		)

			try:
					import librosa
					import soundfile as sf
			except ImportError as err:
					raise ImportError('''To support decoding audio files, please install \'librosa\' and \'soundfile\'.'''		) from err

			lowerCAmelCase__       :      Optional[Any]   					= xsplitext(lowerCAmelCase__		)[1][1:].lower() if path is not None else None
			if not config.IS_OPUS_SUPPORTED and audio_format == "opus":
					raise RuntimeError(
					    '''Decoding \'opus\' files requires system library \'libsndfile\'>=1.0.31, '''
					    '''You can try to update `soundfile` python library: `pip install \"soundfile>=0.12.1\"`. '''		)
			elif not config.IS_MP3_SUPPORTED and audio_format == "mp3":
					raise RuntimeError(
					    '''Decoding \'mp3\' files requires system library \'libsndfile\'>=1.1.0, '''
					    '''You can try to update `soundfile` python library: `pip install \"soundfile>=0.12.1\"`. '''		)

			if file is None:
					lowerCAmelCase__       :      Optional[int]   					= token_per_repo_id or {}
					lowerCAmelCase__       :      str   					= path.split('''::'''		)[-1]
					try:
							lowerCAmelCase__       :      List[str]   					= string_to_dict(lowerCAmelCase__		, config.HUB_DATASETS_URL		)["repo_id"]
							lowerCAmelCase__       :      Any   					= token_per_repo_id[repo_id]
					except (ValueError, KeyError):
							lowerCAmelCase__       :      List[Any]   					= None

					with xopen(lowerCAmelCase__		, '''rb'''		, use_auth_token=lowerCAmelCase__		) as f:
							lowerCAmelCase__       :      Optional[int]   					= sf.read(lowerCAmelCase__		)

			else:
					lowerCAmelCase__       :      Union[str, Any]   					= sf.read(lowerCAmelCase__		)

			lowerCAmelCase__       :      List[Any]   					= array.T
			if self.mono:
					lowerCAmelCase__       :      List[Any]   					= librosa.to_mono(lowerCAmelCase__		)
			if self.sampling_rate and self.sampling_rate != sampling_rate:
					lowerCAmelCase__       :      Optional[int]   					= librosa.resample(lowerCAmelCase__		, orig_sr=lowerCAmelCase__		, target_sr=self.sampling_rate		)
					lowerCAmelCase__       :      str   					= self.sampling_rate

			return {"path": path, "array": array, "sampling_rate": sampling_rate}




	def 							UpperCAmelCase__( self						:		Tuple		)->	Union["FeatureType", Dict[str, "FeatureType"]]:
			from .features import Value

			if self.decode:
					raise ValueError('''Cannot flatten a decoded Audio feature.'''		)
			return {
			    "bytes": Value('''binary'''		),
			    "path": Value('''string'''		),
			}




	def 							UpperCAmelCase__( self						:		Any		, _SCREAMING_SNAKE_CASE						:		Union[pa.StringArray, pa.StructArray]		)->	pa.StructArray:




			if pa.types.is_string(storage.type		):
					lowerCAmelCase__       :      Dict   					= pa.array([None] * len(lowerCAmelCase__		)		, type=pa.binary()		)
					lowerCAmelCase__       :      Union[str, Any]   					= pa.StructArray.from_arrays([bytes_array, storage]		, ['''bytes''', '''path''']		, mask=storage.is_null()		)
			elif pa.types.is_binary(storage.type		):
					lowerCAmelCase__       :      str   					= pa.array([None] * len(lowerCAmelCase__		)		, type=pa.string()		)
					lowerCAmelCase__       :      Optional[Any]   					= pa.StructArray.from_arrays([storage, path_array]		, ['''bytes''', '''path''']		, mask=storage.is_null()		)
			elif pa.types.is_struct(storage.type		) and storage.type.get_all_field_indices('''array'''		):
					lowerCAmelCase__       :      List[str]   					= pa.array([Audio().encode_example(lowerCAmelCase__		) if x is not None else None for x in storage.to_pylist()]		)
			elif pa.types.is_struct(storage.type		):
					if storage.type.get_field_index('''bytes'''		) >= 0:
							lowerCAmelCase__       :      Union[str, Any]   					= storage.field('''bytes'''		)
					else:
							lowerCAmelCase__       :      Tuple   					= pa.array([None] * len(lowerCAmelCase__		)		, type=pa.binary()		)
					if storage.type.get_field_index('''path'''		) >= 0:
							lowerCAmelCase__       :      Union[str, Any]   					= storage.field('''path'''		)
					else:
							lowerCAmelCase__       :      Any   					= pa.array([None] * len(lowerCAmelCase__		)		, type=pa.string()		)
					lowerCAmelCase__       :      int   					= pa.StructArray.from_arrays([bytes_array, path_array]		, ['''bytes''', '''path''']		, mask=storage.is_null()		)
			return array_cast(lowerCAmelCase__		, self.pa_type		)




	def 							UpperCAmelCase__( self						:		List[str]		, _SCREAMING_SNAKE_CASE						:		pa.StructArray		)->	pa.StructArray:




			@no_op_if_value_is_null
			def path_to_bytes(_SCREAMING_SNAKE_CASE						:		Optional[Any]		):
					with xopen(lowerCAmelCase__		, '''rb'''		) as f:
							lowerCAmelCase__       :      Optional[int]   					= f.read()
					return bytes_

			lowerCAmelCase__       :      List[Any]   					= pa.array(
			    [
			        (path_to_bytes(x['''path''']		) if x['''bytes'''] is None else x['''bytes''']) if x is not None else None
			        for x in storage.to_pylist()
			    ]		, type=pa.binary()		, )
			lowerCAmelCase__       :      Any   					= pa.array(
			    [os.path.basename(lowerCAmelCase__		) if path is not None else None for path in storage.field('''path'''		).to_pylist()]		, type=pa.string()		, )
			lowerCAmelCase__       :      Optional[Any]   					= pa.StructArray.from_arrays([bytes_array, path_array]		, ['''bytes''', '''path''']		, mask=bytes_array.is_null()		)
			return array_cast(lowerCAmelCase__		, self.pa_type		)








import gc
import tempfile
import unittest

import numpy as np
import torch

from diffusers import VersatileDiffusionPipeline
from diffusers.utils.testing_utils import load_image, nightly, require_torch_gpu, torch_device


lowerCamelCase						=		False





class  _a							(    unittest.TestCase):
	pass





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




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




	def 							UpperCAmelCase__( self						:		Any		)->	Dict:
			lowerCAmelCase__       :      int   					= VersatileDiffusionPipeline.from_pretrained('''shi-labs/versatile-diffusion'''		, torch_dtype=torch.floataa		)
			pipe.to(_SCREAMING_SNAKE_CASE		)
			pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)

			lowerCAmelCase__       :      List[str]   					= load_image(
			    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg'''		)

			lowerCAmelCase__       :      List[str]   					= torch.manual_seed(0		)
			lowerCAmelCase__       :      List[str]   					= pipe.dual_guided(
			    prompt='''first prompt'''		, image=_SCREAMING_SNAKE_CASE		, text_to_image_strength=0.75		, generator=_SCREAMING_SNAKE_CASE		, guidance_scale=7.5		, num_inference_steps=2		, output_type='''numpy'''		, ).images

			with tempfile.TemporaryDirectory() as tmpdirname:
					pipe.save_pretrained(_SCREAMING_SNAKE_CASE		)
					lowerCAmelCase__       :      List[Any]   					= VersatileDiffusionPipeline.from_pretrained(_SCREAMING_SNAKE_CASE		, torch_dtype=torch.floataa		)
			pipe.to(_SCREAMING_SNAKE_CASE		)
			pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)

			lowerCAmelCase__       :      List[str]   					= generator.manual_seed(0		)
			lowerCAmelCase__       :      str   					= pipe.dual_guided(
			    prompt='''first prompt'''		, image=_SCREAMING_SNAKE_CASE		, text_to_image_strength=0.75		, generator=_SCREAMING_SNAKE_CASE		, guidance_scale=7.5		, num_inference_steps=2		, output_type='''numpy'''		, ).images

			assert np.abs(image - new_image		).sum() < 1E-5, "Models don't have the same forward pass"




	def 							UpperCAmelCase__( self						:		Tuple		)->	List[Any]:
			lowerCAmelCase__       :      Optional[int]   					= VersatileDiffusionPipeline.from_pretrained('''shi-labs/versatile-diffusion'''		, torch_dtype=torch.floataa		)
			pipe.to(_SCREAMING_SNAKE_CASE		)
			pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)

			lowerCAmelCase__       :      int   					= '''cyberpunk 2077'''
			lowerCAmelCase__       :      List[str]   					= load_image(
			    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg'''		)
			lowerCAmelCase__       :      List[Any]   					= torch.manual_seed(0		)
			lowerCAmelCase__       :      Union[str, Any]   					= pipe.dual_guided(
			    prompt=_SCREAMING_SNAKE_CASE		, image=_SCREAMING_SNAKE_CASE		, text_to_image_strength=0.75		, generator=_SCREAMING_SNAKE_CASE		, guidance_scale=7.5		, num_inference_steps=50		, output_type='''numpy'''		, ).images

			lowerCAmelCase__       :      List[Any]   					= image[0, 253:256, 253:256, -1]

			assert image.shape == (1, 512, 512, 3)
			lowerCAmelCase__       :      List[str]   					= np.array([0.1448, 0.1619, 0.1741, 0.1086, 0.1147, 0.1128, 0.1199, 0.1165, 0.1001]		)

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

			lowerCAmelCase__       :      int   					= '''A painting of a squirrel eating a burger '''
			lowerCAmelCase__       :      Optional[Any]   					= torch.manual_seed(0		)
			lowerCAmelCase__       :      Union[str, Any]   					= pipe.text_to_image(
			    prompt=_SCREAMING_SNAKE_CASE		, generator=_SCREAMING_SNAKE_CASE		, guidance_scale=7.5		, num_inference_steps=50		, output_type='''numpy'''		).images

			lowerCAmelCase__       :      List[Any]   					= image[0, 253:256, 253:256, -1]

			assert image.shape == (1, 512, 512, 3)
			lowerCAmelCase__       :      Optional[Any]   					= np.array([0.3367, 0.3169, 0.2656, 0.3870, 0.4790, 0.3796, 0.4009, 0.4878, 0.4778]		)

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

			lowerCAmelCase__       :      Optional[Any]   					= pipe.image_variation(_SCREAMING_SNAKE_CASE		, generator=_SCREAMING_SNAKE_CASE		, output_type='''numpy'''		).images

			lowerCAmelCase__       :      List[Any]   					= image[0, 253:256, 253:256, -1]

			assert image.shape == (1, 512, 512, 3)
			lowerCAmelCase__       :      Any   					= np.array([0.3076, 0.3123, 0.3284, 0.3782, 0.3770, 0.3894, 0.4297, 0.4331, 0.4456]		)

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




