
# Lint as: python3
import itertools
import os
import re


lowercase  :					str													=       re.compile(R'([A-Z]+)([A-Z][a-z])')
lowercase  :					Union[str, Any]													=       re.compile(R'([a-z\d])([A-Z])')

lowercase  :					str													=       re.compile(R'(?<!_)_(?!_)')
lowercase  :					List[Any]													=       re.compile(R'(_{2,})')

lowercase  :					int													=       R'^\w+(\.\w+)*$'

lowercase  :					Any													=       R'<>:/\|?*'




def 	_SCREAMING_SNAKE_CASE					(		_lowerCamelCase :			str)					->    Optional[int]:






							'''simple docstring'''





							__UpperCamelCase	:   Optional[int]			   =					_uppercase_uppercase_re.sub(R"\1_\2"						,  _lowerCamelCase)
							__UpperCamelCase	:   List[Any]			   =					_lowercase_uppercase_re.sub(R"\1_\2"						,  _lowerCamelCase)
							return name.lower()




def 	_SCREAMING_SNAKE_CASE					(		_lowerCamelCase :			Dict)					->    Any:






							'''simple docstring'''





							__UpperCamelCase	:   List[str]			   =					_single_underscore_re.split(_lowerCamelCase)
							__UpperCamelCase	:   Any			   =					[_multiple_underscores_re.split(_lowerCamelCase) for n in name]
							return "".join(n.capitalize() for n in itertools.chain.from_iterable(_lowerCamelCase) if n != "")




def 	_SCREAMING_SNAKE_CASE					(		_lowerCamelCase :			List[str])					->    Union[str, Any]:






							'''simple docstring'''





							if os.path.basename(_lowerCamelCase) != name:
														raise ValueError(F'Should be a dataset name, not a path: {name}')
							return camelcase_to_snakecase(_lowerCamelCase)




def 	_SCREAMING_SNAKE_CASE					(		_lowerCamelCase :			Any						,  _lowerCamelCase :			Tuple)					->    Any:






							'''simple docstring'''





							if os.path.basename(_lowerCamelCase) != name:
														raise ValueError(F'Should be a dataset name, not a path: {name}')
							if not re.match(_split_re						,  _lowerCamelCase):
														raise ValueError(F'Split name should match \'{_split_re}\'\' but got \'{split}\'.')
							return F'{filename_prefix_for_name(_lowerCamelCase)}-{split}'




def 	_SCREAMING_SNAKE_CASE					(		_lowerCamelCase :			Union[str, Any]						,  _lowerCamelCase :			Optional[int]						,  _lowerCamelCase :			Tuple						,  _lowerCamelCase :			List[Any]=None)					->    Union[str, Any]:






							'''simple docstring'''





							__UpperCamelCase	:   Optional[Any]			   =					filename_prefix_for_split(_lowerCamelCase						,  _lowerCamelCase)
							if filetype_suffix:
														prefix += F'.{filetype_suffix}'
							__UpperCamelCase	:   Optional[Any]			   =					os.path.join(_lowerCamelCase						,  _lowerCamelCase)
							return F'{filepath}*'




def 	_SCREAMING_SNAKE_CASE					(		_lowerCamelCase :			int						,  _lowerCamelCase :			str						,  _lowerCamelCase :			Tuple						,  _lowerCamelCase :			List[str]=None						,  _lowerCamelCase :			Optional[int]=None)					->    Optional[int]:






							'''simple docstring'''





							__UpperCamelCase	:   Dict			   =					filename_prefix_for_split(_lowerCamelCase						,  _lowerCamelCase)
							__UpperCamelCase	:   Union[str, Any]			   =					os.path.join(_lowerCamelCase						,  _lowerCamelCase)

							if shard_lengths:
														__UpperCamelCase	:   Dict			   =					len(_lowerCamelCase)
														__UpperCamelCase	:   Tuple			   =					[F'{prefix}-{shard_id:05d}-of-{num_shards:05d}' for shard_id in range(_lowerCamelCase)]
														if filetype_suffix:
																					__UpperCamelCase	:   List[str]			   =					[filename + F'.{filetype_suffix}' for filename in filenames]
														return filenames
							else:
														__UpperCamelCase	:   Optional[int]			   =					prefix
														if filetype_suffix:
																					filename += F'.{filetype_suffix}'
														return [filename]

import argparse
import datetime




def 	_SCREAMING_SNAKE_CASE					(		_lowerCamelCase :			str)					->    str:






							'''simple docstring'''





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

							__UpperCamelCase	:   List[str]			   =					{0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 6, 6: 0}

							# Validate
							if not 0 < len(_lowerCamelCase) < 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 < 8_500:
														raise ValueError(
														    "Year out of range. There has to be some sort of limit...right?")

							# Get datetime obj for validation
							__UpperCamelCase	:   Union[str, Any]			   =					datetime.date(int(_lowerCamelCase)						,  int(_lowerCamelCase)						,  int(_lowerCamelCase))

							# Start math
							if m <= 2:
														__UpperCamelCase	:   Any			   =					y - 1
														__UpperCamelCase	:   Optional[Any]			   =					m + 12
							# maths var
							__UpperCamelCase	:   int			   =					int(str(_lowerCamelCase)[:2])
							__UpperCamelCase	:   int			   =					int(str(_lowerCamelCase)[2:])
							__UpperCamelCase	:   int			   =					int(2.6 * m - 5.3_9)
							__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(_lowerCamelCase)]}!'
							return response


if __name__ == "__main__":
		import doctest

		doctest.testmod()
		lowercase  :					Optional[int]													=       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)'
		)
		lowercase  :					Tuple													=       parser.parse_args()
		zeller(args.date_input)