






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

def 							snake_case (  A__		):
			UpperCAmelCase_	:					Union[str, Any]     	=   {
			    "0": "Sunday",
			    "1": "Monday",
			    "2": "Tuesday",
			    "3": "Wednesday",
			    "4": "Thursday",
			    "5": "Friday",
			    "6": "Saturday",
			}

			UpperCAmelCase_	:					List[Any]     	=   {0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 6, 6: 0}

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

			# Get datetime obj for validation
			UpperCAmelCase_	:					Tuple     	=   datetime.date(int(A__		)      ,int(A__		)      ,int(A__		)		)

			# Start math
			if m <= 2:
						UpperCAmelCase_	:					Union[str, Any]     	=   y - 1
						UpperCAmelCase_	:					Union[str, Any]     	=   m + 12
			# maths var
			UpperCAmelCase_	:					int     	=   int(str(A__		)[:2]		)
			UpperCAmelCase_	:					int     	=   int(str(A__		)[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(A__		)]}!"""
			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)







"""simple docstring"""






import os
import sys

UpperCamelCase__				:Union[str, Any]			   =	os.path.join(os.path.dirname(__file__), """src""")
sys.path.append(SRC_DIR)


from transformers import (
    AutoConfig,
    AutoModel,
    AutoModelForCausalLM,
    AutoModelForMaskedLM,
    AutoModelForQuestionAnswering,
    AutoModelForSequenceClassification,
    AutoTokenizer,
    add_start_docstrings,
)


UpperCamelCase__				:List[Any]			   =	[
    """torch""",
    """numpy""",
    """tokenizers""",
    """filelock""",
    """requests""",
    """tqdm""",
    """regex""",
    """sentencepiece""",
    """sacremoses""",
    """importlib_metadata""",
    """huggingface_hub""",
]





@add_start_docstrings(AutoConfig.__doc__		)
def 				A_       ( *snake_case__       ,					**snake_case__		)					->  int:
			return AutoConfig.from_pretrained(*snake_case__       ,					**snake_case__		)





@add_start_docstrings(AutoTokenizer.__doc__		)
def 				A_       ( *snake_case__       ,					**snake_case__		)					->  int:
			return AutoTokenizer.from_pretrained(*snake_case__       ,					**snake_case__		)





@add_start_docstrings(AutoModel.__doc__		)
def 				A_       ( *snake_case__       ,					**snake_case__		)					->  Dict:
			return AutoModel.from_pretrained(*snake_case__       ,					**snake_case__		)





@add_start_docstrings(AutoModelForCausalLM.__doc__		)
def 				A_       ( *snake_case__       ,					**snake_case__		)					->  Dict:
			return AutoModelForCausalLM.from_pretrained(*snake_case__       ,					**snake_case__		)





@add_start_docstrings(AutoModelForMaskedLM.__doc__		)
def 				A_       ( *snake_case__       ,					**snake_case__		)					->  Dict:
			return AutoModelForMaskedLM.from_pretrained(*snake_case__       ,					**snake_case__		)





@add_start_docstrings(AutoModelForSequenceClassification.__doc__		)
def 				A_       ( *snake_case__       ,					**snake_case__		)					->  Dict:
			return AutoModelForSequenceClassification.from_pretrained(*snake_case__       ,					**snake_case__		)





@add_start_docstrings(AutoModelForQuestionAnswering.__doc__		)
def 				A_       ( *snake_case__       ,					**snake_case__		)					->  Union[str, Any]:
			return AutoModelForQuestionAnswering.from_pretrained(*snake_case__       ,					**snake_case__		)

