
import argparse
import datetime



def   __lowerCAmelCase    (				UpperCAmelCase__					:   str							)	->     str:
							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(UpperCAmelCase__							) < 1_1:
														raise ValueError("""Must be 10 characters long"""							)

							# Get month
							lowerCamelCase_					=       int(date_input[0] + date_input[1]							)
							# Validate
							if not 0 < m < 1_3:
														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 < 3_2:
														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 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
							lowerCamelCase_					=       datetime.date(int(UpperCAmelCase__							)      ,					int(UpperCAmelCase__							)      ,					int(UpperCAmelCase__							)							)

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


if __name__ == "__main__":
		import doctest

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







import fire

from transformers import AutoConfig, AutoModelForSeqaSeqLM, AutoTokenizer



def   __lowerCAmelCase    (				UpperCAmelCase__					:   str      ,					UpperCAmelCase__					:   str      ,					**UpperCAmelCase__					:   List[str]							)	->     Tuple:
							lowerCamelCase_					=       AutoConfig.from_pretrained(UpperCAmelCase__      ,					**UpperCAmelCase__							)
							lowerCamelCase_					=       AutoModelForSeqaSeqLM.from_config(UpperCAmelCase__							)
							model.save_pretrained(UpperCAmelCase__							)
							AutoTokenizer.from_pretrained(UpperCAmelCase__							).save_pretrained(UpperCAmelCase__							)
							return model


if __name__ == "__main__":
		fire.Fire(save_randomly_initialized_version)





