
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)







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


lowercase        =  {
    '''configuration_rag''': ['''RagConfig'''],
    '''retrieval_rag''': ['''RagRetriever'''],
    '''tokenization_rag''': ['''RagTokenizer'''],
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		lowercase        =  [
		    '''RagModel''',
		    '''RagPreTrainedModel''',
		    '''RagSequenceForGeneration''',
		    '''RagTokenForGeneration''',
		]

try:
		if not is_tf_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		lowercase        =  [
		    '''TFRagModel''',
		    '''TFRagPreTrainedModel''',
		    '''TFRagSequenceForGeneration''',
		    '''TFRagTokenForGeneration''',
		]


if TYPE_CHECKING:
		from .configuration_rag import RagConfig
		from .retrieval_rag import RagRetriever
		from .tokenization_rag import RagTokenizer

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_rag import RagModel, RagPreTrainedModel, RagSequenceForGeneration, RagTokenForGeneration

		try:
				if not is_tf_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_tf_rag import (
				    TFRagModel,
				    TFRagPreTrainedModel,
				    TFRagSequenceForGeneration,
				    TFRagTokenForGeneration,
				)

else:
		import sys

		lowercase        =  _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)





