



import argparse
import datetime

def   lowerCAmelCase__						(							_SCREAMING_SNAKE_CASE       :			str    ):
				"""simple docstring"""







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

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

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

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

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

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

				# Start math
				if m <= 2:
								__a       =		y - 1
								__a       =		m + 12
				# maths var
				__a       =		int(str(_SCREAMING_SNAKE_CASE    )[:2]    )
				__a       =		int(str(_SCREAMING_SNAKE_CASE    )[2:]    )
				__a       =		int(2.6 * m - 5.39    )
				__a       =		int(c / 4    )
				__a       =		int(k / 4    )
				__a       =		int(d + k    )
				__a       =		int(t + u + v + x    )
				__a       =		int(z - (2 * c)    )
				__a       =		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
				__a       =		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)





from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


lowerCamelCase__			= {"""configuration_mbart""": ["""MBART_PRETRAINED_CONFIG_ARCHIVE_MAP""", """MBartConfig""", """MBartOnnxConfig"""]}

try:
						if not is_sentencepiece_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCamelCase__			= ["""MBartTokenizer"""]

try:
						if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCamelCase__			= ["""MBartTokenizerFast"""]

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCamelCase__			= [
						    """MBART_PRETRAINED_MODEL_ARCHIVE_LIST""",
						    """MBartForCausalLM""",
						    """MBartForConditionalGeneration""",
						    """MBartForQuestionAnswering""",
						    """MBartForSequenceClassification""",
						    """MBartModel""",
						    """MBartPreTrainedModel""",
						]

try:
						if not is_tf_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCamelCase__			= [
						    """TFMBartForConditionalGeneration""",
						    """TFMBartModel""",
						    """TFMBartPreTrainedModel""",
						]

try:
						if not is_flax_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCamelCase__			= [
						    """FlaxMBartForConditionalGeneration""",
						    """FlaxMBartForQuestionAnswering""",
						    """FlaxMBartForSequenceClassification""",
						    """FlaxMBartModel""",
						    """FlaxMBartPreTrainedModel""",
						]


if TYPE_CHECKING:
						from .configuration_mbart import MBART_PRETRAINED_CONFIG_ARCHIVE_MAP, MBartConfig, MBartOnnxConfig

						try:
												if not is_sentencepiece_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .tokenization_mbart import MBartTokenizer

						try:
												if not is_tokenizers_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .tokenization_mbart_fast import MBartTokenizerFast

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_mbart import (
												    MBART_PRETRAINED_MODEL_ARCHIVE_LIST,
												    MBartForCausalLM,
												    MBartForConditionalGeneration,
												    MBartForQuestionAnswering,
												    MBartForSequenceClassification,
												    MBartModel,
												    MBartPreTrainedModel,
												)

						try:
												if not is_tf_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_tf_mbart import TFMBartForConditionalGeneration, TFMBartModel, TFMBartPreTrainedModel

						try:
												if not is_flax_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_flax_mbart import (
												    FlaxMBartForConditionalGeneration,
												    FlaxMBartForQuestionAnswering,
												    FlaxMBartForSequenceClassification,
												    FlaxMBartModel,
												    FlaxMBartPreTrainedModel,
												)

else:
						import sys

						lowerCamelCase__			= _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
