





import argparse
import datetime



def        __lowercase       (				_SCREAMING_SNAKE_CASE     )			->       str:


      '''simple docstring'''


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

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

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

      # Get day
      SCREAMING_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
      SCREAMING_SNAKE_CASE		=						date_input[5]
      # Validate
      if sep_a not in ["-", "/"]:
            raise ValueError("""Date separator must be '-' or '/'"""     )

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

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


if __name__ == "__main__":
      import doctest

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









from typing import TYPE_CHECKING

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


SCREAMING_SNAKE_CASE_						       =	{"""configuration_reformer""": ["""REFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP""", """ReformerConfig"""]}

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

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

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      SCREAMING_SNAKE_CASE_						       =	[
          """REFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""",
          """ReformerAttention""",
          """ReformerForMaskedLM""",
          """ReformerForQuestionAnswering""",
          """ReformerForSequenceClassification""",
          """ReformerLayer""",
          """ReformerModel""",
          """ReformerModelWithLMHead""",
          """ReformerPreTrainedModel""",
      ]


if TYPE_CHECKING:
      from .configuration_reformer import REFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, ReformerConfig

      try:
            if not is_sentencepiece_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_reformer import ReformerTokenizer

      try:
            if not is_tokenizers_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_reformer_fast import ReformerTokenizerFast

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_reformer import (
                REFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
                ReformerAttention,
                ReformerForMaskedLM,
                ReformerForQuestionAnswering,
                ReformerForSequenceClassification,
                ReformerLayer,
                ReformerModel,
                ReformerModelWithLMHead,
                ReformerPreTrainedModel,
            )

else:
      import sys

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


