

'''simple docstring'''




import argparse
import datetime


def    lowerCamelCase__		(    SCREAMING_SNAKE_CASE   : Tuple    ):
  UpperCAmelCase    				=						{
      '0': 'Sunday',
      '1': 'Monday',
      '2': 'Tuesday',
      '3': 'Wednesday',
      '4': 'Thursday',
      '5': 'Friday',
      '6': 'Saturday',
  }

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

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

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

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

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


if __name__ == "__main__":
  import doctest

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






import importlib
import shutil
import threading
import warnings
from typing import List

import fsspec
import fsspec.asyn

from . import compression
from .hffilesystem import HfFileSystem


SCREAMING_SNAKE_CASE							    =							importlib.util.find_spec('s3fs') is not None

if _has_safs:
  from .safilesystem import SaFileSystem  # noqa: F401

SCREAMING_SNAKE_CASE							    =							[
    compression.BzaFileSystem,
    compression.GzipFileSystem,
    compression.LzaFileSystem,
    compression.XzFileSystem,
    compression.ZstdFileSystem,
]

# Register custom filesystems
for fs_class in COMPRESSION_FILESYSTEMS + [HfFileSystem]:
  if fs_class.protocol in fsspec.registry and fsspec.registry[fs_class.protocol] is not fs_class:
    warnings.warn(f'''A filesystem protocol was already set for {fs_class.protocol} and will be overwritten.''')
  fsspec.register_implementation(fs_class.protocol, fs_class, clobber=True)




def  a   (lowerCAmelCase__   ):
   if "://" in dataset_path:
      __a					=  dataset_path.split("""://"""   )[1]
   return dataset_path




def  a   (lowerCAmelCase__   ):
   if fs is not None and fs.protocol != "file":
      return True
   else:
      return False




def  a   (lowerCAmelCase__		,				lowerCAmelCase__		,				lowerCAmelCase__   ):
   __a					=  not is_remote_filesystem(lowerCAmelCase__   )
   if is_local:
      # LocalFileSystem.mv does copy + rm, it is more efficient to simply move a local directory
      shutil.move(fs._strip_protocol(lowerCAmelCase__   )		,				fs._strip_protocol(lowerCAmelCase__   )   )
   else:
      fs.mv(lowerCAmelCase__		,				lowerCAmelCase__		,				recursive=lowerCAmelCase__   )




def  a   ():
   if hasattr(fsspec.asyn		,				"""reset_lock"""   ):
      # for future fsspec>2022.05.0
      fsspec.asyn.reset_lock()
   else:
      __a					=  None
      __a					=  None
      __a					=  threading.Lock()



