






'''simple docstring'''

import argparse
import datetime



def 				snake_case       (  a_				:			str						)							->					str:





      """simple docstring"""

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

      UpperCamelCase_					: Union[str, 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 < 8_500:
            raise ValueError(
                """Year out of range. There has to be some sort of limit...right?"""						)

      # Get datetime obj for validation
      UpperCamelCase_					: Union[str, Any]            =				datetime.date(int(a_						)     , int(a_						)     , int(a_						)						)

      # Start math
      if m <= 2:
            UpperCamelCase_					: int            =				y - 1
            UpperCamelCase_					: List[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()
      UpperCamelCase      					=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)"
      )
      UpperCamelCase      					=parser.parse_args()
      zeller(args.date_input)














'''simple docstring'''

from ...utils import (
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_torch_available,
    is_transformers_available,
)


try:
      if not (is_transformers_available() and is_torch_available()):
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
      from .multicontrolnet import MultiControlNetModel
      from .pipeline_controlnet import StableDiffusionControlNetPipeline
      from .pipeline_controlnet_imgaimg import StableDiffusionControlNetImgaImgPipeline
      from .pipeline_controlnet_inpaint import StableDiffusionControlNetInpaintPipeline


if is_transformers_available() and is_flax_available():
      from .pipeline_flax_controlnet import FlaxStableDiffusionControlNetPipeline






