



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__     = False, False, False







@dataclass
class     __lowerCAmelCase					:
			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=A       ,		repr=A		)



			def __call__(							self     :						Tuple)     ->					List[Any]:



						"""simple docstring"""






						return self.pa_type



			def 					_lowerCamelCase (							self     :						Dict				,	A     :						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(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	 =     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	 =     np.frombuffer(value['bytes']				,	dtype=np.intaa).astype(np.floataa) / 3_27_67
												else:
															_UpperCAmelCase	 =     np.memmap(value['path']				,	dtype='h'				,	mode='r').astype(np.floataa) / 3_27_67

												_UpperCAmelCase	 =     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 					_lowerCamelCase (							self     :						Dict				,	A     :						dict				,	A     :						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(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	 =     token_per_repo_id or {}
									_UpperCAmelCase	 =     path.split('::')[-1]
									try:
												_UpperCAmelCase	 =     string_to_dict(A				,	config.HUB_DATASETS_URL)['repo_id']
												_UpperCAmelCase	 =     token_per_repo_id[repo_id]
									except (ValueError, KeyError):
												_UpperCAmelCase	 =     None

									with xopen(A				,	'rb'				,	use_auth_token=A) as f:
												_UpperCAmelCase ,  _UpperCAmelCase	 =     sf.read(A)

						else:
									_UpperCAmelCase ,  _UpperCAmelCase	 =     sf.read(A)

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

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



			def 					_lowerCamelCase (							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 					_lowerCamelCase (							self     :						Dict				,	A     :						Union[pa.StringArray, pa.StructArray])     ->					pa.StructArray:



						"""simple docstring"""






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



			def 					_lowerCamelCase (							self     :						Any				,	A     :						pa.StructArray)     ->					pa.StructArray:



						"""simple docstring"""






						@no_op_if_value_is_null
						def path_to_bytes(A     :						Any):
									with xopen(A				,	'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(A) 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(A				,	self.pa_type)





def 							A			(  _UpperCAmelCase       :     int							,     _UpperCAmelCase       :     int					)       ->				int:







			'''simple docstring'''
			while second != 0:
						_UpperCAmelCase	 =     first & second
						first ^= second
						_UpperCAmelCase	 =     c << 1
			return first


if __name__ == "__main__":
							import doctest

							doctest.testmod()

							UpperCAmelCase__     = int(input("Enter the first number: ").strip())
							UpperCAmelCase__     = int(input("Enter the second number: ").strip())
							print(f"""{add(first, second) = }""")
