




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							:    Tuple  							=							False, False, False






@dataclass
class 					__magic_name__							:






				'''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				):





							"""simple docstring"""
							return self.pa_type





				def      _lowerCAmelCase       ( self	,				_a				):





							"""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(_a	,				_a				):
										return {"bytes": None, "path": value}
							elif isinstance(_a	,				_a				):
										return {"bytes": value, "path": None}
							elif "array" in value:
										# convert the audio array to wav bytes
										lowerCamelCase       =      BytesIO()
										sf.write(_a	,				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       =      np.frombuffer(value["""bytes"""]	,				dtype=np.intaa				).astype(np.floataa				) / 32_767
													else:
																lowerCamelCase       =      np.memmap(value["""path"""]	,				dtype="""h"""	,				mode="""r"""				).astype(np.floataa				) / 32_767

													lowerCamelCase       =      BytesIO(bytes()				)
													sf.write(_a	,				_a	,				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      _lowerCAmelCase       ( self	,				_a	,				_a = None				):





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

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

										with xopen(_a	,				"""rb"""	,				use_auth_token=_a				) as f:
													lowerCamelCase   ,     lowerCamelCase       =      sf.read(_a				)

							else:
										lowerCamelCase   ,     lowerCamelCase       =      sf.read(_a				)

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

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





				def      _lowerCAmelCase       ( self				):





							"""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      _lowerCAmelCase       ( self	,				_a				):





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





				def      _lowerCAmelCase       ( self	,				_a				):





							"""simple docstring"""

							@no_op_if_value_is_null
							def path_to_bytes(_a				):
										with xopen(_a	,				"""rb"""				) as f:
													lowerCamelCase       =      f.read()
										return bytes_

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









"""simple docstring"""




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


lowerCAmelCase							:    Dict  							=							logging.get_logger(__name__)

lowerCAmelCase							:    Optional[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 					__magic_name__							( UpperCAmelCase__       ):






				'''simple docstring'''
				__UpperCamelCase    						=		"audio-spectrogram-transformer"





				def __init__( self	,				_a=768	,				_a=12	,				_a=12	,				_a=3_072	,				_a="gelu"	,				_a=0.0	,				_a=0.0	,				_a=0.02	,				_a=1e-1_2	,				_a=16	,				_a=True	,				_a=10	,				_a=10	,				_a=1_024	,				_a=128	,				**_a	,				):





							"""simple docstring"""
							super().__init__(**_a				)

							lowerCamelCase       =      hidden_size
							lowerCamelCase       =      num_hidden_layers
							lowerCamelCase       =      num_attention_heads
							lowerCamelCase       =      intermediate_size
							lowerCamelCase       =      hidden_act
							lowerCamelCase       =      hidden_dropout_prob
							lowerCamelCase       =      attention_probs_dropout_prob
							lowerCamelCase       =      initializer_range
							lowerCamelCase       =      layer_norm_eps
							lowerCamelCase       =      patch_size
							lowerCamelCase       =      qkv_bias
							lowerCamelCase       =      frequency_stride
							lowerCamelCase       =      time_stride
							lowerCamelCase       =      max_length
							lowerCamelCase       =      num_mel_bins



