






import argparse
import datetime

def    SCREAMING_SNAKE_CASE_							(							__magic_name__					:  str					)		->			str:






	"""simple docstring"""



	UpperCamelCase     :Union[str, Any]          =	{
	    """0""": """Sunday""",
	    """1""": """Monday""",
	    """2""": """Tuesday""",
	    """3""": """Wednesday""",
	    """4""": """Thursday""",
	    """5""": """Friday""",
	    """6""": """Saturday""",
	}

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

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

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

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

	# Get day
	UpperCamelCase     :int          =	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     :str          =	date_input[5]
	# Validate
	if sep_a not in ["-", "/"]:
		raise ValueError("""Date separator must be '-' or '/'"""					)

	# Get year
	UpperCamelCase     :int          =	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     :Optional[Any]          =	datetime.date(int(__magic_name__					)	,			int(__magic_name__					)	,			int(__magic_name__					)					)

	# Start math
	if m <= 2:
		UpperCamelCase     :Dict          =	y - 1
		UpperCamelCase     :Union[str, Any]          =	m + 12
	# maths var
	UpperCamelCase     :int          =	int(str(__magic_name__					)[:2]					)
	UpperCamelCase     :int          =	int(str(__magic_name__					)[2:]					)
	UpperCamelCase     :int          =	int(2.6 * m - 5.39					)
	UpperCamelCase     :int          =	int(c / 4					)
	UpperCamelCase     :int          =	int(k / 4					)
	UpperCamelCase     :int          =	int(d + k					)
	UpperCamelCase     :int          =	int(t + u + v + x					)
	UpperCamelCase     :int          =	int(z - (2 * c)					)
	UpperCamelCase     :int          =	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     :str          =	f"""Your date {date_input}, is a {days[str(__magic_name__					)]}!"""
	return response


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	UpperCAmelCase_ :						List[Any]      =      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_ :						Tuple      =      parser.parse_args()
	zeller(args.date_input)








import copy
from dataclasses import dataclass, field
from typing import ClassVar, Dict

from ..features import Audio, Features, Value
from .base import TaskTemplate

@dataclass(frozen=_a      )
class     _SCREAMING_SNAKE_CASE       (			_a      ):
	snake_case__							:     str     	=  field(default="""automatic-speech-recognition"""		,   metadata={"""include_in_asdict_even_if_is_default""": True}      )
	snake_case__							:     ClassVar[Features]     	=  Features({"""audio""": Audio()}      )
	snake_case__							:     ClassVar[Features]     	=  Features({"""transcription""": Value("""string"""      )}      )
	snake_case__							:     str     	=  "audio"
	snake_case__							:     str     	=  "transcription"





	def 						_A (		self				:					List[str] ,  __lowerCamelCase				:					Dict	):
		if self.audio_column not in features:
			raise ValueError(F"""Column {self.audio_column} is not present in features."""	)
		if not isinstance(features[self.audio_column] ,  __lowerCamelCase	):
			raise ValueError(F"""Column {self.audio_column} is not an Audio type."""	)
		UpperCamelCase     :int          =	copy.deepcopy(self	)
		UpperCamelCase     :Any          =	self.input_schema.copy()
		UpperCamelCase     :List[str]          =	features[self.audio_column]
		UpperCamelCase     :List[Any]          =	input_schema
		return task_template





	@property
	def 						_A (		self				:					Optional[int]	):
		return {self.audio_column: "audio", self.transcription_column: "transcription"}
