


'''simple docstring'''







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     :  Union[str, Any]											=    False, False, False
@dataclass
class 						UpperCamelCase__       :



     """simple docstring"""






     __magic_name__           =     None
     __magic_name__           =     True
     __magic_name__           =     True
     __magic_name__           =     None
     # Automatically constructed
     __magic_name__           =     "dict"
     __magic_name__           =     pa.struct({"bytes": pa.binary(), "path": pa.string()}						)
     __magic_name__           =     field(default="Audio"     ,       init=SCREAMING_SNAKE_CASE_     ,       repr=SCREAMING_SNAKE_CASE_						)







     def __call__(			self ):

            '''simple docstring'''

            return self.pa_type







     def a						(			self   ,						snake_case__ ):

            '''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(snake_case__   ,						snake_case__ ):
                   return {"bytes": None, "path": value}
            elif isinstance(snake_case__   ,						snake_case__ ):
                   return {"bytes": value, "path": None}
            elif "array" in value:
                   # convert the audio array to wav bytes
                   _lowerCAmelCase     :				Optional[int]       =							BytesIO()
                   sf.write(snake_case__   ,						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     :				List[Any]       =							BytesIO(bytes() )
                          sf.write(snake_case__   ,						snake_case__   ,						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 a						(			self   ,						snake_case__   ,						snake_case__ = None ):

            '''simple docstring'''

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

            _lowerCAmelCase      ,  _lowerCAmelCase     :				Any       =							(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     :				str       =							xsplitext(snake_case__ )[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[Any]       =							token_per_repo_id or {}
                   _lowerCAmelCase     :				str       =							path.split('::' )[-1]
                   try:
                          _lowerCAmelCase     :				List[Any]       =							string_to_dict(snake_case__   ,						config.HUB_DATASETS_URL )['repo_id']
                          _lowerCAmelCase     :				List[str]       =							token_per_repo_id[repo_id]
                   except (ValueError, KeyError):
                          _lowerCAmelCase     :				Optional[int]       =							None

                   with xopen(snake_case__   ,						'rb'   ,						use_auth_token=snake_case__ ) as f:
                          _lowerCAmelCase      ,  _lowerCAmelCase     :				int       =							sf.read(snake_case__ )

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

            _lowerCAmelCase     :				Dict       =							array.T
            if self.mono:
                   _lowerCAmelCase     :				int       =							librosa.to_mono(snake_case__ )
            if self.sampling_rate and self.sampling_rate != sampling_rate:
                   _lowerCAmelCase     :				Tuple       =							librosa.resample(snake_case__   ,						orig_sr=snake_case__   ,						target_sr=self.sampling_rate )
                   _lowerCAmelCase     :				Optional[int]       =							self.sampling_rate

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







     def a						(			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 a						(			self   ,						snake_case__ ):

            '''simple docstring'''

            if pa.types.is_string(storage.type ):
                   _lowerCAmelCase     :				Optional[Any]       =							pa.array([None] * len(snake_case__ )   ,						type=pa.binary() )
                   _lowerCAmelCase     :				Dict       =							pa.StructArray.from_arrays([bytes_array, storage]   ,						['bytes', 'path']   ,						mask=storage.is_null() )
            elif pa.types.is_binary(storage.type ):
                   _lowerCAmelCase     :				Dict       =							pa.array([None] * len(snake_case__ )   ,						type=pa.string() )
                   _lowerCAmelCase     :				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     :				Union[str, Any]       =							pa.array([Audio().encode_example(snake_case__ ) 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     :				Dict       =							pa.array([None] * len(snake_case__ )   ,						type=pa.binary() )
                   if storage.type.get_field_index('path' ) >= 0:
                          _lowerCAmelCase     :				Tuple       =							storage.field('path' )
                   else:
                          _lowerCAmelCase     :				Any       =							pa.array([None] * len(snake_case__ )   ,						type=pa.string() )
                   _lowerCAmelCase     :				Optional[int]       =							pa.StructArray.from_arrays([bytes_array, path_array]   ,						['bytes', 'path']   ,						mask=storage.is_null() )
            return array_cast(snake_case__   ,						self.pa_type )







     def a						(			self   ,						snake_case__ ):

            '''simple docstring'''

            @no_op_if_value_is_null
            def path_to_bytes(snake_case__ ):
                   with xopen(snake_case__   ,						'rb' ) as f:
                          _lowerCAmelCase     :				Tuple       =							f.read()
                   return bytes_

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





'''simple docstring'''







from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


lowerCAmelCase     :  List[str]											=    {
    """configuration_electra""": ["""ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP""", """ElectraConfig""", """ElectraOnnxConfig"""],
    """tokenization_electra""": ["""ElectraTokenizer"""],
}

try:
       if not is_tokenizers_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowerCAmelCase     :  Optional[Any]											=    ["""ElectraTokenizerFast"""]

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowerCAmelCase     :  str											=    [
           """ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST""",
           """ElectraForCausalLM""",
           """ElectraForMaskedLM""",
           """ElectraForMultipleChoice""",
           """ElectraForPreTraining""",
           """ElectraForQuestionAnswering""",
           """ElectraForSequenceClassification""",
           """ElectraForTokenClassification""",
           """ElectraModel""",
           """ElectraPreTrainedModel""",
           """load_tf_weights_in_electra""",
       ]

try:
       if not is_tf_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowerCAmelCase     :  Tuple											=    [
           """TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST""",
           """TFElectraForMaskedLM""",
           """TFElectraForMultipleChoice""",
           """TFElectraForPreTraining""",
           """TFElectraForQuestionAnswering""",
           """TFElectraForSequenceClassification""",
           """TFElectraForTokenClassification""",
           """TFElectraModel""",
           """TFElectraPreTrainedModel""",
       ]

try:
       if not is_flax_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowerCAmelCase     :  Union[str, Any]											=    [
           """FlaxElectraForCausalLM""",
           """FlaxElectraForMaskedLM""",
           """FlaxElectraForMultipleChoice""",
           """FlaxElectraForPreTraining""",
           """FlaxElectraForQuestionAnswering""",
           """FlaxElectraForSequenceClassification""",
           """FlaxElectraForTokenClassification""",
           """FlaxElectraModel""",
           """FlaxElectraPreTrainedModel""",
       ]


if TYPE_CHECKING:
       from .configuration_electra import ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, ElectraConfig, ElectraOnnxConfig
       from .tokenization_electra import ElectraTokenizer

       try:
              if not is_tokenizers_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .tokenization_electra_fast import ElectraTokenizerFast

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_electra import (
                  ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST,
                  ElectraForCausalLM,
                  ElectraForMaskedLM,
                  ElectraForMultipleChoice,
                  ElectraForPreTraining,
                  ElectraForQuestionAnswering,
                  ElectraForSequenceClassification,
                  ElectraForTokenClassification,
                  ElectraModel,
                  ElectraPreTrainedModel,
                  load_tf_weights_in_electra,
              )

       try:
              if not is_tf_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_tf_electra import (
                  TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST,
                  TFElectraForMaskedLM,
                  TFElectraForMultipleChoice,
                  TFElectraForPreTraining,
                  TFElectraForQuestionAnswering,
                  TFElectraForSequenceClassification,
                  TFElectraForTokenClassification,
                  TFElectraModel,
                  TFElectraPreTrainedModel,
              )

       try:
              if not is_flax_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_flax_electra import (
                  FlaxElectraForCausalLM,
                  FlaxElectraForMaskedLM,
                  FlaxElectraForMultipleChoice,
                  FlaxElectraForPreTraining,
                  FlaxElectraForQuestionAnswering,
                  FlaxElectraForSequenceClassification,
                  FlaxElectraForTokenClassification,
                  FlaxElectraModel,
                  FlaxElectraPreTrainedModel,
              )

else:
       import sys

       lowerCAmelCase     :  int											=    _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

