



'''simple docstring'''






import argparse
import datetime




def     snake_case_					(     lowerCAmelCase_		)->		str:





       '''simple docstring'''


       _UpperCAmelCase  :						Dict			     = {
           """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(lowerCAmelCase_		) < 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 < 8500:
              raise ValueError(
                  """Year out of range. There has to be some sort of limit...right?"""		)

       # Get datetime obj for validation
       _UpperCAmelCase  :						Tuple			     = datetime.date(int(lowerCAmelCase_		)       ,   int(lowerCAmelCase_		)       ,   int(lowerCAmelCase_		)		)

       # Start math
       if m <= 2:
              _UpperCAmelCase  :						str			     = y - 1
              _UpperCAmelCase  :						Union[str, Any]			     = m + 12
       # maths var
       _UpperCAmelCase  :						int			     = int(str(lowerCAmelCase_		)[:2]		)
       _UpperCAmelCase  :						int			     = int(str(lowerCAmelCase_		)[2:]		)
       _UpperCAmelCase  :						int			     = int(2.6 * m - 5.3_9		)
       _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(lowerCAmelCase_		)]}!'''
       return response


if __name__ == "__main__":
   import doctest

   doctest.testmod()
   A_							: Any						 =	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)"""
   )
   A_							: Union[str, Any]						 =	parser.parse_args()
   zeller(args.date_input)








'''simple docstring'''






import unittest

from transformers import load_tool

from .test_tools_common import ToolTesterMixin



class 							lowercase       (  unittest.TestCase					,					_lowerCamelCase				):


 """simple docstring"""


 def _snake_case (							self							)		->   Any:
        _UpperCAmelCase  :						int			     = load_tool("""text-classification"""							)
        self.tool.setup()
        _UpperCAmelCase  :						Tuple			     = load_tool("""text-classification"""  ,remote=a_							)







 def _snake_case (							self							)		->   Union[str, Any]:
        _UpperCAmelCase  :						Tuple			     = self.tool("""That's quite cool"""  ,["""positive""", """negative"""]							)
        self.assertEqual(a_  ,"""positive"""							)







 def _snake_case (							self							)		->   Any:
        _UpperCAmelCase  :						Dict			     = self.remote_tool("""That's quite cool"""  ,["""positive""", """negative"""]							)
        self.assertEqual(a_  ,"""positive"""							)







 def _snake_case (							self							)		->   str:
        _UpperCAmelCase  :						List[Any]			     = self.tool(text="""That's quite cool"""  ,labels=["""positive""", """negative"""]							)
        self.assertEqual(a_  ,"""positive"""							)







 def _snake_case (							self							)		->   Union[str, Any]:
        _UpperCAmelCase  :						Any			     = self.remote_tool(text="""That's quite cool"""  ,labels=["""positive""", """negative"""]							)
        self.assertEqual(a_  ,"""positive"""							)



