



"""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  			=		False, False, False
@dataclass
class  lowercase__  :







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


             '''simple docstring'''




             return self.pa_type



       def 	lowercase__							(				self     :    List[Any]						,							_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(__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
                   UpperCAmelCase_     					=				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!)
                               UpperCAmelCase_     					=				np.frombuffer(value["bytes"]						,							dtype=np.intaa       ).astype(np.floataa       ) / 32767
                         else:
                               UpperCAmelCase_     					=				np.memmap(value["path"]						,							dtype="h"						,							mode="r"       ).astype(np.floataa       ) / 32767

                         UpperCAmelCase_     					=				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 	lowercase__							(				self     :    Any						,							_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."       )

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

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

             else:
                   UpperCAmelCase_					,       UpperCAmelCase_     					=				sf.read(__lowerCamelCase       )

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

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



       def 	lowercase__							(				self     :    int       )					->		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 	lowercase__							(				self     :    List[Any]						,							_UpperCAmelCase     :    Union[pa.StringArray, pa.StructArray]       )					->		pa.StructArray:


             '''simple docstring'''




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







       def 	lowercase__							(				self     :    Union[str, Any]						,							_UpperCAmelCase     :    pa.StructArray       )					->		pa.StructArray:


             '''simple docstring'''




             @no_op_if_value_is_null
             def path_to_bytes(_UpperCAmelCase     :    Any       ):
                   with xopen(__lowerCamelCase						,							"rb"       ) as f:
                         UpperCAmelCase_     					=				f.read()
                   return bytes_

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











from math import factorial



def  SCREAMING_SNAKE_CASE				(      snake_case						,   snake_case							)		->    int:

		# If either of the conditions are true, the function is being asked
		# to calculate a factorial of a negative number, which is not possible
		if n < k or k < 0:
				raise ValueError('Please enter positive integers for n and k where n >= k'							)
		return factorial(snake_case							) // (factorial(snake_case							) * factorial(n - k							))


if __name__ == "__main__":
		print(
		    '''The number of five-card hands possible from a standard''',
		    F"""fifty-two card deck is: {combinations(52, 5)}\n""",
		)

		print(
		    '''If a class of 40 students must be arranged into groups of''',
		    F"""4 for group projects, there are {combinations(40, 4)} ways""",
		    '''to arrange them.\n''',
		)

		print(
		    '''If 10 teams are competing in a Formula One race, there''',
		    F"""are {combinations(10, 3)} ways that first, second and""",
		    '''third place can be awarded.''',
		)




