"""simple docstring"""




import argparse
import datetime







def 				_UpperCAmelCase		(							lowerCamelCase__  ):





		"""simple docstring"""




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

		lowerCAmelCase__   = {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
		lowerCAmelCase__   = int(date_input[0] + date_input[1]  )
		# Validate
		if not 0 < m < 13:
				raise ValueError("""Month must be between 1 - 12"""  )

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

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

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

		# Get year
		lowerCAmelCase__   = 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
		lowerCAmelCase__   = datetime.date(int(lowerCamelCase__  )      ,	int(lowerCamelCase__  )      ,	int(lowerCamelCase__  )  )

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


if __name__ == "__main__":
			import doctest

			doctest.testmod()
			__lowerCAmelCase     :				str    				=    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)"
			)
			__lowerCAmelCase     :				Optional[Any]    				=    parser.parse_args()
			zeller(args.date_input)





"""simple docstring"""




from operator import delitem, getitem, setitem

import pytest

from data_structures.hashing.hash_map import HashMap







def 				_UpperCAmelCase		(							lowerCamelCase__  ):





		"""simple docstring"""




		return getitem, k







def 				_UpperCAmelCase		(							lowerCamelCase__      ,	lowerCamelCase__  ):





		"""simple docstring"""




		return setitem, k, v







def 				_UpperCAmelCase		(							lowerCamelCase__  ):





		"""simple docstring"""




		return delitem, k







def 				_UpperCAmelCase		(							lowerCamelCase__      ,	lowerCamelCase__      ,	*lowerCamelCase__  ):





		"""simple docstring"""




		try:
				return fun(lowerCamelCase__      ,	*lowerCamelCase__  ), None
		except Exception as e:
				return None, e


__lowerCAmelCase     :				Optional[Any]    				=    (
    _set("key_a", "val_a"),
    _set("key_b", "val_b"),
)

__lowerCAmelCase     :				Optional[int]    				=    [
    _set("key_a", "val_a"),
    _set("key_a", "val_b"),
]

__lowerCAmelCase     :				List[Any]    				=    [
    _set("key_a", "val_a"),
    _set("key_b", "val_b"),
    _del("key_a"),
    _del("key_b"),
    _set("key_a", "val_a"),
    _del("key_a"),
]

__lowerCAmelCase     :				int    				=    [
    _get("key_a"),
    _del("key_a"),
    _set("key_a", "val_a"),
    _del("key_a"),
    _del("key_a"),
    _get("key_a"),
]

__lowerCAmelCase     :				Optional[Any]    				=    [
    *[_set(x, x) for x in range(5)],  # guaranteed upsize
]

__lowerCAmelCase     :				Any    				=    [
    *[_set(x, x) for x in range(5)],  # guaranteed upsize
    *[_del(x) for x in range(5)],
    _set("key_a", "val_b"),
]







@pytest.mark.parametrize(
    """operations"""      ,	(
        pytest.param(_add_items      ,	id="""add items"""  ),
        pytest.param(_overwrite_items      ,	id="""overwrite items"""  ),
        pytest.param(_delete_items      ,	id="""delete items"""  ),
        pytest.param(_access_absent_items      ,	id="""access absent items"""  ),
        pytest.param(_add_with_resize_up      ,	id="""add with resize up"""  ),
        pytest.param(_add_with_resize_down      ,	id="""add with resize down"""  ),
    )      ,	)
def 				_UpperCAmelCase		(							lowerCamelCase__  ):





		"""simple docstring"""




		lowerCAmelCase__   = HashMap(initial_block_size=4  )
		lowerCAmelCase__   = {}
		for _, (fun, *args) in enumerate(lowerCamelCase__  ):
				lowerCAmelCase__ ,       lowerCAmelCase__   = _run_operation(lowerCamelCase__      ,	lowerCamelCase__      ,	*lowerCamelCase__  )
				lowerCAmelCase__ ,       lowerCAmelCase__   = _run_operation(lowerCamelCase__      ,	lowerCamelCase__      ,	*lowerCamelCase__  )
				assert my_res == py_res
				assert str(lowerCamelCase__  ) == str(lowerCamelCase__  )
				assert set(lowerCamelCase__  ) == set(lowerCamelCase__  )
				assert len(lowerCamelCase__  ) == len(lowerCamelCase__  )
				assert set(my.items()  ) == set(py.items()  )







def 				_UpperCAmelCase		(							):





		"""simple docstring"""




		def is_public(lowerCamelCase__  ) -> bool:
				return not name.startswith("""_"""  )

		lowerCAmelCase__   = {name for name in dir({}  ) if is_public(lowerCamelCase__  )}
		lowerCAmelCase__   = {name for name in dir(HashMap()  ) if is_public(lowerCamelCase__  )}

		assert dict_public_names > hash_public_names




