




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


@dataclass
class     UpperCamelCase_   :

    '''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[int])						->Any:





           '''simple docstring'''

           return self.pa_type


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

                         A__							=   BytesIO(bytes())
                         sf.write(UpperCAmelCase__ ,			UpperCAmelCase__ ,			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 	SCREAMING_SNAKE_CASE							(      self				:     Dict ,			UpperCAmelCase__				:     dict ,			UpperCAmelCase__				:     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.''')

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

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

                  with xopen(UpperCAmelCase__ ,			'''rb''' ,			use_auth_token=UpperCAmelCase__) as f:
                         A__			,							A__							=   sf.read(UpperCAmelCase__)

           else:
                  A__			,							A__							=   sf.read(UpperCAmelCase__)

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

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


    def 	SCREAMING_SNAKE_CASE							(      self				:     Any)						->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 	SCREAMING_SNAKE_CASE							(      self				:     str ,			UpperCAmelCase__				:     Union[pa.StringArray, pa.StructArray])						->pa.StructArray:





           '''simple docstring'''

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





    def 	SCREAMING_SNAKE_CASE							(      self				:     List[Any] ,			UpperCAmelCase__				:     pa.StructArray)						->pa.StructArray:





           '''simple docstring'''

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

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








from __future__ import annotations

from typing import Any







def SCREAMING_SNAKE_CASE    (	lowercase_						)       ->	None:



       """simple docstring"""

       create_state_space_tree(lowercase_			,    []			,    0						)







def SCREAMING_SNAKE_CASE    (	lowercase_			,    lowercase_			,    lowercase_						)       ->	None:



       """simple docstring"""

       if index == len(lowercase_						):
              print(lowercase_						)
              return

       create_state_space_tree(lowercase_			,    lowercase_			,    index + 1						)
       current_subsequence.append(sequence[index]						)
       create_state_space_tree(lowercase_			,    lowercase_			,    index + 1						)
       current_subsequence.pop()


if __name__ == "__main__":
  _lowerCamelCase     :		list[Any]								=       [3, 1, 2, 4]
  generate_all_subsequences(seq)

  seq.clear()
  seq.extend(["""A""", """B""", """C"""])
  generate_all_subsequences(seq)


