
"""simple docstring"""
import argparse
import datetime





def    _lowerCAmelCase    (     lowerCamelCase__							:							str				)  ->    str:
  _SCREAMING_SNAKE_CASE   :				List[str]							    = {
      "0": "Sunday",
      "1": "Monday",
      "2": "Tuesday",
      "3": "Wednesday",
      "4": "Thursday",
      "5": "Friday",
      "6": "Saturday",
  }

  _SCREAMING_SNAKE_CASE   :				Optional[int]							    = {0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 6, 6: 0}

  # Validate
  if not 0 < len(lowerCamelCase__				) < 1_1:
    raise ValueError("Must be 10 characters long"				)

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

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

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

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

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

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

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


if __name__ == "__main__":
     import doctest

     doctest.testmod()
     lowercase_       :						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)'''
     )
     lowercase_       :						Tuple     					=	parser.parse_args()
     zeller(args.date_input)





"""simple docstring"""
from typing import List

from .keymap import KEYMAP, get_character





def    _lowerCAmelCase    (     lowerCamelCase__							:							str				)  ->    Optional[int]:

  def decorator(lowerCamelCase__							:							int				):
    _SCREAMING_SNAKE_CASE   :				Optional[int]							    = getattr(lowerCamelCase__,						"handle_key",						[]				)
    handle += [key]
    setattr(lowerCamelCase__,						"handle_key",						lowerCamelCase__				)
    return func

  return decorator





def    _lowerCAmelCase    (     *lowerCamelCase__							:							List[str]				)  ->    Tuple:

  def decorator(lowerCamelCase__							:							Dict				):
    _SCREAMING_SNAKE_CASE   :				List[Any]							    = getattr(lowerCamelCase__,						"handle_key",						[]				)
    handle += keys
    setattr(lowerCamelCase__,						"handle_key",						lowerCamelCase__				)
    return func

  return decorator
class 			UpperCamelCase      (							__SCREAMING_SNAKE_CASE  ):
     def __new__(     cls  ,     snake_case__  ,     snake_case__  ,     snake_case__				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				Tuple							    = super().__new__(cls  ,     snake_case__  ,     snake_case__  ,     snake_case__				)
       if not hasattr(snake_case__  ,     "key_handler"				):
         setattr(snake_case__  ,     "key_handler"  ,     {}				)
       setattr(snake_case__  ,     "handle_input"  ,     KeyHandler.handle_input				)

       for value in attrs.values():
         _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = getattr(snake_case__  ,     "handle_key"  ,     []				)
         for key in handled_keys:
           _SCREAMING_SNAKE_CASE   :				Tuple							    = value
       return new_cls




     @staticmethod
     def 				__SCREAMING_SNAKE_CASE							(     cls				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				Any							    = get_character()
       if char != KEYMAP["undefined"]:
         _SCREAMING_SNAKE_CASE   :				Dict							    = ord(snake_case__				)
       _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = cls.key_handler.get(snake_case__				)
       if handler:
         _SCREAMING_SNAKE_CASE   :				Optional[int]							    = char
         return handler(cls				)
       else:
         return None





def    _lowerCAmelCase    (     cls							:							List[Any]				)  ->    str:
  return KeyHandler(cls.__name__,						cls.__bases__,						cls.__dict__.copy()				)



