





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 :  List[str]										=  False, False, False



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





      def __call__(				self     ):
       '''simple docstring'''




       return self.pa_type





      def  __UpperCamelCase(				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
        UpperCamelCase			:      Optional[int] 			=     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!)
          UpperCamelCase			:      Dict 			=     np.frombuffer(value["bytes"] ,							dtype=np.intaa     ).astype(np.floataa     ) / 3_2767
         else:
          UpperCamelCase			:      Any 			=     np.memmap(value["path"] ,							dtype="h" ,							mode="r"     ).astype(np.floataa     ) / 3_2767

         UpperCamelCase			:      List[str] 			=     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  __UpperCamelCase(				self ,							A_ ,							A_ = None     ):
       '''simple docstring'''




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

       UpperCamelCase			,					UpperCamelCase			:      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

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

        with xopen(A_ ,							"rb" ,							use_auth_token=A_     ) as f:
         UpperCamelCase			,					UpperCamelCase			:      List[str] 			=     sf.read(A_     )

       else:
        UpperCamelCase			,					UpperCamelCase			:      Any 			=     sf.read(A_     )

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

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





      def  __UpperCamelCase(				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  __UpperCamelCase(				self ,							A_     ):
       '''simple docstring'''




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





      def  __UpperCamelCase(				self ,							A_     ):
       '''simple docstring'''




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

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







def 	A_       (  _lowerCAmelCase							,     _lowerCAmelCase  )		->				int:
 return int(input_a == input_a == 0  )



def 	A_       (  )		->				None:
 print("Truth Table of NOR Gate:"  )
 print("|   Input 1   |  Input 2  | Output |"  )
 print(F"""|      0      |    0      |  {nor_gate(0							,     0  )}     |"""  )
 print(F"""|      0      |    1      |  {nor_gate(0							,     1  )}     |"""  )
 print(F"""|      1      |    0      |  {nor_gate(1							,     0  )}     |"""  )
 print(F"""|      1      |    1      |  {nor_gate(1							,     1  )}     |"""  )


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    main()
