


'''simple docstring'''


from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching







def      snake_case_  (    ):







				"""simple docstring"""





				import os as original_os
				from os import path as original_path
				from os import rename as original_rename
				from os.path import dirname as original_dirname
				from os.path import join as original_join

				assert _test_patching.os is original_os
				assert _test_patching.path is original_path
				assert _test_patching.join is original_join

				assert _test_patching.renamed_os is original_os
				assert _test_patching.renamed_path is original_path
				assert _test_patching.renamed_join is original_join

				_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= """__test_patch_submodule_mock__"""
				with patch_submodule(_test_patching				, """os.path.join"""				, SCREAMING_SNAKE_CASE__	):
								# Every way to access os.path.join must be patched, and the rest must stay untouched

								# check os.path.join
								assert isinstance(_test_patching.os				, _PatchedModuleObj	)
								assert isinstance(_test_patching.os.path				, _PatchedModuleObj	)
								assert _test_patching.os.path.join is mock

								# check path.join
								assert isinstance(_test_patching.path				, _PatchedModuleObj	)
								assert _test_patching.path.join is mock

								# check join
								assert _test_patching.join is mock

								# check that the other attributes are untouched
								assert _test_patching.os.rename is original_rename
								assert _test_patching.path.dirname is original_dirname
								assert _test_patching.os.path.dirname is original_dirname

								# Even renamed modules or objects must be patched

								# check renamed_os.path.join
								assert isinstance(_test_patching.renamed_os				, _PatchedModuleObj	)
								assert isinstance(_test_patching.renamed_os.path				, _PatchedModuleObj	)
								assert _test_patching.renamed_os.path.join is mock

								# check renamed_path.join
								assert isinstance(_test_patching.renamed_path				, _PatchedModuleObj	)
								assert _test_patching.renamed_path.join is mock

								# check renamed_join
								assert _test_patching.renamed_join is mock

								# check that the other attributes are untouched
								assert _test_patching.renamed_os.rename is original_rename
								assert _test_patching.renamed_path.dirname is original_dirname
								assert _test_patching.renamed_os.path.dirname is original_dirname

				# check that everthing is back to normal when the patch is over

				assert _test_patching.os is original_os
				assert _test_patching.path is original_path
				assert _test_patching.join is original_join

				assert _test_patching.renamed_os is original_os
				assert _test_patching.renamed_path is original_path
				assert _test_patching.renamed_join is original_join







def      snake_case_  (    ):







				"""simple docstring"""





				assert _test_patching.open is open

				_SCREAMING_SNAKE_CASE					:			Dict							= """__test_patch_submodule_builtin_mock__"""
				# _test_patching has "open" in its globals
				assert _test_patching.open is open
				with patch_submodule(_test_patching				, """open"""				, SCREAMING_SNAKE_CASE__	):
								assert _test_patching.open is mock

				# check that everthing is back to normal when the patch is over

				assert _test_patching.open is open







def      snake_case_  (    ):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE					:			Any							= """__test_patch_submodule_missing_mock__"""
				with patch_submodule(_test_patching				, """pandas.read_csv"""				, SCREAMING_SNAKE_CASE__	):
								pass







def      snake_case_  (    ):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE					:			int							= """__test_patch_submodule_missing_builtin_mock__"""
				# _test_patching doesn't have "len" in its globals
				assert getattr(_test_patching				, """len"""				, SCREAMING_SNAKE_CASE__	) is None
				with patch_submodule(_test_patching				, """len"""				, SCREAMING_SNAKE_CASE__	):
								assert _test_patching.len is mock
				assert _test_patching.len is len







def      snake_case_  (    ):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE					:			int							= """__test_patch_submodule_start_and_stop_mock__"""
				_SCREAMING_SNAKE_CASE					:			List[Any]							= patch_submodule(_test_patching				, """open"""				, SCREAMING_SNAKE_CASE__	)
				assert _test_patching.open is open
				patch.start()
				assert _test_patching.open is mock
				patch.stop()
				assert _test_patching.open is open







def      snake_case_  (    ):







				"""simple docstring"""





				from os import rename as original_rename
				from os.path import dirname as original_dirname
				from os.path import join as original_join

				_SCREAMING_SNAKE_CASE					:			Any							= """__test_patch_submodule_successive_join__"""
				_SCREAMING_SNAKE_CASE					:			Optional[Any]							= """__test_patch_submodule_successive_dirname__"""
				_SCREAMING_SNAKE_CASE					:			str							= """__test_patch_submodule_successive_rename__"""
				assert _test_patching.os.path.join is original_join
				assert _test_patching.os.path.dirname is original_dirname
				assert _test_patching.os.rename is original_rename

				with patch_submodule(_test_patching				, """os.path.join"""				, SCREAMING_SNAKE_CASE__	):
								with patch_submodule(_test_patching				, """os.rename"""				, SCREAMING_SNAKE_CASE__	):
												with patch_submodule(_test_patching				, """os.path.dirname"""				, SCREAMING_SNAKE_CASE__	):
																assert _test_patching.os.path.join is mock_join
																assert _test_patching.os.path.dirname is mock_dirname
																assert _test_patching.os.rename is mock_rename

    # try another order
				with patch_submodule(_test_patching				, """os.rename"""				, SCREAMING_SNAKE_CASE__	):
								with patch_submodule(_test_patching				, """os.path.join"""				, SCREAMING_SNAKE_CASE__	):
												with patch_submodule(_test_patching				, """os.path.dirname"""				, SCREAMING_SNAKE_CASE__	):
																assert _test_patching.os.path.join is mock_join
																assert _test_patching.os.path.dirname is mock_dirname
																assert _test_patching.os.rename is mock_rename

				assert _test_patching.os.path.join is original_join
				assert _test_patching.os.path.dirname is original_dirname
				assert _test_patching.os.rename is original_rename







def      snake_case_  (    ):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE					:			int							= """__test_patch_submodule_doesnt_exist_mock__"""
				with patch_submodule(_test_patching				, """__module_that_doesn_exist__.__attribute_that_doesn_exist__"""				, SCREAMING_SNAKE_CASE__	):
								pass
				with patch_submodule(_test_patching				, """os.__attribute_that_doesn_exist__"""				, SCREAMING_SNAKE_CASE__	):
								pass








'''simple docstring'''


import argparse
import datetime







def      snake_case_  (    SCREAMING_SNAKE_CASE__	):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE					:			Optional[int]							= {
				    """0""": """Sunday""",
				    """1""": """Monday""",
				    """2""": """Tuesday""",
				    """3""": """Wednesday""",
				    """4""": """Thursday""",
				    """5""": """Friday""",
				    """6""": """Saturday""",
				}

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

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

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

				# Get year
				_SCREAMING_SNAKE_CASE					:			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
				_SCREAMING_SNAKE_CASE					:			Optional[int]							= datetime.date(int(SCREAMING_SNAKE_CASE__	)				, int(SCREAMING_SNAKE_CASE__	)				, int(SCREAMING_SNAKE_CASE__	)	)

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


if __name__ == "__main__":
				import doctest

				doctest.testmod()
				UpperCAmelCase_						:  Tuple				  =						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_						:  List[Any]				  =						parser.parse_args()
				zeller(args.date_input)




