





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        __SCREAMING_SNAKE_CASE					:
							snake_case     :      Optional[int]						     =       None
							snake_case     :      bool						     =       True
							snake_case     :      bool						     =       True
							snake_case     :      Optional[str]						     =       None
							# Automatically constructed
							snake_case     :      ClassVar[str]						     =       "dict"
							snake_case     :      ClassVar[Any]						     =       pa.struct({"""bytes""": pa.binary(), """path""": pa.string()}       )
							snake_case     :      str						     =       field(default="""Audio"""   ,		init=_a   ,		repr=_a       )






							def __call__(						self  ):
														return self.pa_type






							def 				_lowerCamelCase		(						self  , __lowerCAmelCase  ):
														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 				_lowerCamelCase		(						self  , __lowerCAmelCase  , __lowerCAmelCase = None  ):
														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 				_lowerCamelCase		(						self  ):
														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  , __lowerCAmelCase  ):
														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 				_lowerCamelCase		(						self  , __lowerCAmelCase  ):

														@no_op_if_value_is_null
														def path_to_bytes(__lowerCAmelCase  ):
																					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  )











import argparse
import datetime





def     _UpperCamelCase     (a__   :str       ):






							"""simple docstring"""





							UpperCamelCase__				     =			{
							    """0""": """Sunday""",
							    """1""": """Monday""",
							    """2""": """Tuesday""",
							    """3""": """Wednesday""",
							    """4""": """Thursday""",
							    """5""": """Friday""",
							    """6""": """Saturday""",
							}

							UpperCamelCase__				     =			{0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 6, 6: 0}

							# Validate
							if not 0 < len(a__       ) < 11:
														raise ValueError("""Must be 10 characters long"""       )

							# Get month
							UpperCamelCase__				     =			int(date_input[0] + date_input[1]       )
							# Validate
							if not 0 < m < 13:
														raise ValueError("""Month must be between 1 - 12"""       )

							UpperCamelCase__				     =			date_input[2]
							# Validate
							if sep_a not in ["-", "/"]:
														raise ValueError("""Date separator must be '-' or '/'"""       )

							# Get day
							UpperCamelCase__				     =			int(date_input[3] + date_input[4]       )
							# Validate
							if not 0 < d < 32:
														raise ValueError("""Date must be between 1 - 31"""       )

							# Get second separator
							UpperCamelCase__				     =			date_input[5]
							# Validate
							if sep_a not in ["-", "/"]:
														raise ValueError("""Date separator must be '-' or '/'"""       )

							# Get year
							UpperCamelCase__				     =			int(date_input[6] + date_input[7] + date_input[8] + date_input[9]       )
							# Arbitrary year range
							if not 45 < y < 8500:
														raise ValueError(
														    """Year out of range. There has to be some sort of limit...right?"""       )

							# Get datetime obj for validation
							UpperCamelCase__				     =			datetime.date(int(a__       )   ,			int(a__       )   ,			int(a__       )       )

							# Start math
							if m <= 2:
														UpperCamelCase__				     =			y - 1
														UpperCamelCase__				     =			m + 12
							# maths var
							UpperCamelCase__				     =			int(str(a__       )[:2]       )
							UpperCamelCase__				     =			int(str(a__       )[2:]       )
							UpperCamelCase__				     =			int(2.6 * m - 5.39       )
							UpperCamelCase__				     =			int(c / 4       )
							UpperCamelCase__				     =			int(k / 4       )
							UpperCamelCase__				     =			int(d + k       )
							UpperCamelCase__				     =			int(t + u + v + x       )
							UpperCamelCase__				     =			int(z - (2 * c)       )
							UpperCamelCase__				     =			round(w % 7       )
							# End math

							# Validate math
							if f != convert_datetime_days[dt_ck.weekday()]:
														raise AssertionError("""The date was evaluated incorrectly. Contact developer."""       )

							# Response
							UpperCamelCase__				     =			f"""Your date {date_input}, is a {days[str(a__       )]}!"""
							return response


if __name__ == "__main__":
					import doctest

					doctest.testmod()
					UpperCamelCase__											= argparse.ArgumentParser(
					    description=(
					        "Find out what day of the week nearly any date is or was. Enter "
					        "date as a string in the mm-dd-yyyy or mm/dd/yyyy format"
					    )
					)
					parser.add_argument(
					    "date_input", type=str, help="Date as a string (mm-dd-yyyy or mm/dd/yyyy)"
					)
					UpperCamelCase__											= parser.parse_args()
					zeller(args.date_input)




