


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


__UpperCamelCase  ,							__UpperCamelCase  ,							__UpperCamelCase    :						Tuple     =							False, False, False



@dataclass
class 							_UpperCamelCase :

   '''simple docstring'''







   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=A,repr=A						)

   def __call__(  self  : str							):






         '''simple docstring'''



         return self.pa_type

   def   _snake_case    (  self  : List[Any]       ,  _lowerCamelCase  : Union[str, bytes, 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
               __lowerCamelCase     :      List[Any]       						=						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     :      Dict       						=						np.frombuffer(value["""bytes"""]       ,  dtype=np.intaa							).astype(np.floataa							) / 3_2_7_6_7
                     else:
                           __lowerCamelCase     :      str       						=						np.memmap(value["""path"""]       ,  dtype="""h"""       ,  mode="""r"""							).astype(np.floataa							) / 3_2_7_6_7

                     __lowerCamelCase     :      Union[str, 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   _snake_case    (  self  : int       ,  _lowerCamelCase  : dict       ,  _lowerCamelCase  : Optional[Dict[str, Union[str, bool, None]]] = None							):






         '''simple docstring'''



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

         __lowerCamelCase						, __lowerCamelCase     :      Optional[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     :      List[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     :      Union[str, Any]       						=						token_per_repo_id or {}
               __lowerCamelCase     :      Dict       						=						path.split("""::"""							)[-1]
               try:
                     __lowerCamelCase     :      str       						=						string_to_dict(_lowerCamelCase       ,  config.HUB_DATASETS_URL							)["""repo_id"""]
                     __lowerCamelCase     :      str       						=						token_per_repo_id[repo_id]
               except (ValueError, KeyError):
                     __lowerCamelCase     :      str       						=						None

               with xopen(_lowerCamelCase       ,  """rb"""       ,  use_auth_token=_lowerCamelCase							) as f:
                     __lowerCamelCase						, __lowerCamelCase     :      Tuple       						=						sf.read(_lowerCamelCase							)

         else:
               __lowerCamelCase						, __lowerCamelCase     :      int       						=						sf.read(_lowerCamelCase							)

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

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

   def   _snake_case    (  self  : Optional[int]							):






         '''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   _snake_case    (  self  : Tuple       ,  _lowerCamelCase  : Union[pa.StringArray, pa.StructArray]							):






         '''simple docstring'''



         if pa.types.is_string(storage.type							):
               __lowerCamelCase     :      Union[str, Any]       						=						pa.array([None] * len(_lowerCamelCase							)       ,  type=pa.binary()							)
               __lowerCamelCase     :      Optional[int]       						=						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(_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[Any]       						=						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     :      Any       						=						storage.field("""bytes"""							)
               else:
                     __lowerCamelCase     :      List[Any]       						=						pa.array([None] * len(_lowerCamelCase							)       ,  type=pa.binary()							)
               if storage.type.get_field_index("""path"""							) >= 0:
                     __lowerCamelCase     :      str       						=						storage.field("""path"""							)
               else:
                     __lowerCamelCase     :      List[str]       						=						pa.array([None] * len(_lowerCamelCase							)       ,  type=pa.string()							)
               __lowerCamelCase     :      Tuple       						=						pa.StructArray.from_arrays([bytes_array, path_array]       ,  ["""bytes""", """path"""]       ,  mask=storage.is_null()							)
         return array_cast(_lowerCamelCase       ,  self.pa_type							)


   def   _snake_case    (  self  : str       ,  _lowerCamelCase  : pa.StructArray							):






         '''simple docstring'''



         @no_op_if_value_is_null
         def path_to_bytes(_lowerCamelCase  : int							):
               with xopen(_lowerCamelCase       ,  """rb"""							) as f:
                     __lowerCamelCase     :      Dict       						=						f.read()
               return bytes_

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







def   _UpperCAmelCase       (     UpperCAmelCase      :			int = 4_000_000      ):
      """simple docstring"""




      __lowerCamelCase     :      Union[str, Any]       						=						[0, 1]
      __lowerCamelCase     :      Dict       						=						0
      while fib[i] <= n:
            fib.append(fib[i] + fib[i + 1]      )
            if fib[i + 2] > n:
                  break
            i += 1
      __lowerCamelCase     :      Any       						=						0
      for j in range(len(UpperCAmelCase      ) - 1      ):
            if fib[j] % 2 == 0:
                  total += fib[j]

      return total


if __name__ == "__main__":
    print(F'''{solution() = }''')



