

import argparse
import datetime


def   __SCREAMING_SNAKE_CASE					(SCREAMING_SNAKE_CASE__       ):
						snake_case_   =	{
						    '''0''': '''Sunday''',
						    '''1''': '''Monday''',
						    '''2''': '''Tuesday''',
						    '''3''': '''Wednesday''',
						    '''4''': '''Thursday''',
						    '''5''': '''Friday''',
						    '''6''': '''Saturday''',
						}

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

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

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

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

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

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

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

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


if __name__ == "__main__":
					import doctest

					doctest.testmod()
					lowerCAmelCase_       	=	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_       	=	parser.parse_args()
					zeller(args.date_input)


import unittest

from transformers.testing_utils import CaptureStdout
from transformers.tools.python_interpreter import evaluate


def   __SCREAMING_SNAKE_CASE					(SCREAMING_SNAKE_CASE__       ):
						return x + 2





class 	snake_case_   (		unittest.TestCase					):







			'''simple docstring'''

			def 				snake_case__(     self :				Optional[Any]							)      ->int:
									snake_case_   =	'''x = 3'''
									snake_case_   =	{}
									snake_case_   =	evaluate(_UpperCamelCase							,   {}							,   state=_UpperCamelCase							)
									assert result == 3
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3}							)

									snake_case_   =	'''x = y'''
									snake_case_   =	{'''y''': 5}
									snake_case_   =	evaluate(_UpperCamelCase							,   {}							,   state=_UpperCamelCase							)
									# evaluate returns the value of the last assignment.
									assert result == 5
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 5, '''y''': 5}							)







			def 				snake_case__(     self :				Dict							)      ->Optional[int]:
									snake_case_   =	'''y = add_two(x)'''
									snake_case_   =	{'''x''': 3}
									snake_case_   =	evaluate(_UpperCamelCase							,   {'''add_two''': add_two}							,   state=_UpperCamelCase							)
									assert result == 5
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3, '''y''': 5}							)

									# Won't work without the tool
									with CaptureStdout() as out:
															snake_case_   =	evaluate(_UpperCamelCase							,   {}							,   state=_UpperCamelCase							)
									assert result is None
									assert "tried to execute add_two" in out.out







			def 				snake_case__(     self :				Union[str, Any]							)      ->Dict:
									snake_case_   =	'''x = 3'''
									snake_case_   =	{}
									snake_case_   =	evaluate(_UpperCamelCase							,   {}							,   state=_UpperCamelCase							)
									assert result == 3
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3}							)







			def 				snake_case__(     self :				Optional[int]							)      ->Optional[int]:
									snake_case_   =	'''test_dict = {\'x\': x, \'y\': add_two(x)}'''
									snake_case_   =	{'''x''': 3}
									snake_case_   =	evaluate(_UpperCamelCase							,   {'''add_two''': add_two}							,   state=_UpperCamelCase							)
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3, '''y''': 5}							)
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3, '''test_dict''': {'''x''': 3, '''y''': 5}}							)







			def 				snake_case__(     self :				Dict							)      ->str:
									snake_case_   =	'''x = 3\ny = 5'''
									snake_case_   =	{}
									snake_case_   =	evaluate(_UpperCamelCase							,   {}							,   state=_UpperCamelCase							)
									# evaluate returns the value of the last assignment.
									assert result == 5
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3, '''y''': 5}							)







			def 				snake_case__(     self :				str							)      ->Tuple:
									snake_case_   =	'''text = f\'This is x: {x}.\''''
									snake_case_   =	{'''x''': 3}
									snake_case_   =	evaluate(_UpperCamelCase							,   {}							,   state=_UpperCamelCase							)
									# evaluate returns the value of the last assignment.
									assert result == "This is x: 3."
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3, '''text''': '''This is x: 3.'''}							)







			def 				snake_case__(     self :				Optional[Any]							)      ->List[str]:
									snake_case_   =	'''if x <= 3:\n    y = 2\nelse:\n    y = 5'''
									snake_case_   =	{'''x''': 3}
									snake_case_   =	evaluate(_UpperCamelCase							,   {}							,   state=_UpperCamelCase							)
									# evaluate returns the value of the last assignment.
									assert result == 2
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3, '''y''': 2}							)

									snake_case_   =	{'''x''': 8}
									snake_case_   =	evaluate(_UpperCamelCase							,   {}							,   state=_UpperCamelCase							)
									# evaluate returns the value of the last assignment.
									assert result == 5
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 8, '''y''': 5}							)







			def 				snake_case__(     self :				str							)      ->str:
									snake_case_   =	'''test_list = [x, add_two(x)]'''
									snake_case_   =	{'''x''': 3}
									snake_case_   =	evaluate(_UpperCamelCase							,   {'''add_two''': add_two}							,   state=_UpperCamelCase							)
									self.assertListEqual(_UpperCamelCase							,   [3, 5]							)
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3, '''test_list''': [3, 5]}							)







			def 				snake_case__(     self :				Any							)      ->List[Any]:
									snake_case_   =	'''y = x'''
									snake_case_   =	{'''x''': 3}
									snake_case_   =	evaluate(_UpperCamelCase							,   {}							,   state=_UpperCamelCase							)
									assert result == 3
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3, '''y''': 3}							)







			def 				snake_case__(     self :				Optional[int]							)      ->Dict:
									snake_case_   =	'''test_list = [x, add_two(x)]\ntest_list[1]'''
									snake_case_   =	{'''x''': 3}
									snake_case_   =	evaluate(_UpperCamelCase							,   {'''add_two''': add_two}							,   state=_UpperCamelCase							)
									assert result == 5
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3, '''test_list''': [3, 5]}							)

									snake_case_   =	'''test_dict = {\'x\': x, \'y\': add_two(x)}\ntest_dict[\'y\']'''
									snake_case_   =	{'''x''': 3}
									snake_case_   =	evaluate(_UpperCamelCase							,   {'''add_two''': add_two}							,   state=_UpperCamelCase							)
									assert result == 5
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3, '''test_dict''': {'''x''': 3, '''y''': 5}}							)







			def 				snake_case__(     self :				Optional[Any]							)      ->int:
									snake_case_   =	'''x = 0\nfor i in range(3):\n    x = i'''
									snake_case_   =	{}
									snake_case_   =	evaluate(_UpperCamelCase							,   {'''range''': range}							,   state=_UpperCamelCase							)
									assert result == 2
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 2, '''i''': 2}							)