






from ...configuration_utils import PretrainedConfig
from ...utils import logging


SCREAMING_SNAKE_CASE__		:							Tuple 				=				logging.get_logger(__name__)

SCREAMING_SNAKE_CASE__		:							List[Any] 				=				{
    """MIT/ast-finetuned-audioset-10-10-0.4593""": (
        """https://huggingface.co/MIT/ast-finetuned-audioset-10-10-0.4593/resolve/main/config.json"""
    ),
}







class 				UpperCAmelCase_  (		__lowerCamelCase		):
     __lowerCamelCase      				=  'audio-spectrogram-transformer'




     def __init__(				self	,						_lowerCAmelCase=768	,						_lowerCAmelCase=12	,						_lowerCAmelCase=12	,						_lowerCAmelCase=3072	,						_lowerCAmelCase="gelu"	,						_lowerCAmelCase=0.0	,						_lowerCAmelCase=0.0	,						_lowerCAmelCase=0.0_2	,						_lowerCAmelCase=1e-12	,						_lowerCAmelCase=16	,						_lowerCAmelCase=True	,						_lowerCAmelCase=10	,						_lowerCAmelCase=10	,						_lowerCAmelCase=1024	,						_lowerCAmelCase=128	,						**_lowerCAmelCase	,						):
          super().__init__(**_lowerCAmelCase		)

          UpperCAmelCase__      :  Optional[int]				      =			hidden_size
          UpperCAmelCase__      :  int				      =			num_hidden_layers
          UpperCAmelCase__      :  List[Any]				      =			num_attention_heads
          UpperCAmelCase__      :  Dict				      =			intermediate_size
          UpperCAmelCase__      :  Dict				      =			hidden_act
          UpperCAmelCase__      :  str				      =			hidden_dropout_prob
          UpperCAmelCase__      :  str				      =			attention_probs_dropout_prob
          UpperCAmelCase__      :  Tuple				      =			initializer_range
          UpperCAmelCase__      :  Dict				      =			layer_norm_eps
          UpperCAmelCase__      :  Optional[Any]				      =			patch_size
          UpperCAmelCase__      :  Tuple				      =			qkv_bias
          UpperCAmelCase__      :  Tuple				      =			frequency_stride
          UpperCAmelCase__      :  Union[str, Any]				      =			time_stride
          UpperCAmelCase__      :  Optional[Any]				      =			max_length
          UpperCAmelCase__      :  Optional[int]				      =			num_mel_bins













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


SCREAMING_SNAKE_CASE_	,SCREAMING_SNAKE_CASE_	,SCREAMING_SNAKE_CASE_   :      Any			=   False, False, False

@dataclass
class 		snake_case_   :







	'''simple docstring'''
	__UpperCamelCase   =		None
	__UpperCamelCase   =		True
	__UpperCamelCase   =		True
	__UpperCamelCase   =		None
	# Automatically constructed
	__UpperCamelCase   =		"dict"
	__UpperCamelCase   =		pa.struct({'''bytes''': pa.binary(), '''path''': pa.string()}						)
	__UpperCamelCase   =		field(default='''Audio'''     ,     init=UpperCAmelCase_     ,     repr=UpperCAmelCase_						)




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

			'''simple docstring'''




			return self.pa_type




	def    UpperCAmelCase			(						self							:     List[Any]					,      __lowerCamelCase							:     Union[str, bytes, dict]   )       -> dict:

			'''simple docstring'''




			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
					__lowercase											=     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!)
									__lowercase											=     np.frombuffer(value['bytes']					,      dtype=np.intaa   ).astype(np.floataa   ) / 32_767
							else:
									__lowercase											=     np.memmap(value['path']					,      dtype='h'					,      mode='r'   ).astype(np.floataa   ) / 32_767

							__lowercase											=     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							:     Any					,      __lowerCamelCase							:     dict					,      __lowerCamelCase							:     Optional[Dict[str, Union[str, bool, None]]] = None   )       -> dict:

			'''simple docstring'''




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

			__lowercase						,      __lowercase											=     (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

			__lowercase											=     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:
					__lowercase											=     token_per_repo_id or {}
					__lowercase											=     path.split('::'   )[-1]
					try:
							__lowercase											=     string_to_dict(__lowerCamelCase					,      config.HUB_DATASETS_URL   )['repo_id']
							__lowercase											=     token_per_repo_id[repo_id]
					except (ValueError, KeyError):
							__lowercase											=     None

					with xopen(__lowerCamelCase					,      'rb'					,      use_auth_token=__lowerCamelCase   ) as f:
							__lowercase						,      __lowercase											=     sf.read(__lowerCamelCase   )

			else:
					__lowercase						,      __lowercase											=     sf.read(__lowerCamelCase   )

			__lowercase											=     array.T
			if self.mono:
					__lowercase											=     librosa.to_mono(__lowerCamelCase   )
			if self.sampling_rate and self.sampling_rate != sampling_rate:
					__lowercase											=     librosa.resample(__lowerCamelCase					,      orig_sr=__lowerCamelCase					,      target_sr=self.sampling_rate   )
					__lowercase											=     self.sampling_rate

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




	def    UpperCAmelCase			(						self							:     int   )       -> Union["FeatureType", Dict[str, "FeatureType"]]:

			'''simple docstring'''




			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							:     List[Any]					,      __lowerCamelCase							:     Union[pa.StringArray, pa.StructArray]   )       -> pa.StructArray:

			'''simple docstring'''




			if pa.types.is_string(storage.type   ):
					__lowercase											=     pa.array([None] * len(__lowerCamelCase   )					,      type=pa.binary()   )
					__lowercase											=     pa.StructArray.from_arrays([bytes_array, storage]					,      ['bytes', 'path']					,      mask=storage.is_null()   )
			elif pa.types.is_binary(storage.type   ):
					__lowercase											=     pa.array([None] * len(__lowerCamelCase   )					,      type=pa.string()   )
					__lowercase											=     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'   ):
					__lowercase											=     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:
							__lowercase											=     storage.field('bytes'   )
					else:
							__lowercase											=     pa.array([None] * len(__lowerCamelCase   )					,      type=pa.binary()   )
					if storage.type.get_field_index('path'   ) >= 0:
							__lowercase											=     storage.field('path'   )
					else:
							__lowercase											=     pa.array([None] * len(__lowerCamelCase   )					,      type=pa.string()   )
					__lowercase											=     pa.StructArray.from_arrays([bytes_array, path_array]					,      ['bytes', 'path']					,      mask=storage.is_null()   )
			return array_cast(__lowerCamelCase					,      self.pa_type   )






	def    UpperCAmelCase			(						self							:     Union[str, Any]					,      __lowerCamelCase							:     pa.StructArray   )       -> pa.StructArray:

			'''simple docstring'''




			@no_op_if_value_is_null
			def path_to_bytes(__lowerCamelCase							:     Any   ):
					with xopen(__lowerCamelCase					,      'rb'   ) as f:
							__lowercase											=     f.read()
					return bytes_

			__lowercase											=     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()					,      )
			__lowercase											=     pa.array(
			    [os.path.basename(__lowerCamelCase   ) if path is not None else None for path in storage.field('path'   ).to_pylist()]					,      type=pa.string()					,      )
			__lowercase											=     pa.StructArray.from_arrays([bytes_array, path_array]					,      ['bytes', 'path']					,      mask=bytes_array.is_null()   )
			return array_cast(__lowerCamelCase					,      self.pa_type   )




