


import argparse
import datetime
def     __lowerCamelCase						(			UpperCAmelCase_						:		str						):




      """simple docstring"""





      a						:List[str]										=	{
          '0': 'Sunday',
          '1': 'Monday',
          '2': 'Tuesday',
          '3': 'Wednesday',
          '4': 'Thursday',
          '5': 'Friday',
          '6': 'Saturday',
      }

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

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

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

      # Get year
      a						: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
      a						:Dict										=	datetime.date(int(__a						)			,  int(__a						)			,  int(__a						)						)

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


if __name__ == "__main__":
   import doctest

   doctest.testmod()
   snake_case    :   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)'''
   )
   snake_case    :   Tuple	    =					parser.parse_args()
   zeller(args.date_input)









from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


snake_case    :   Optional[Any]	    =					logging.get_logger(__name__)

snake_case    :   Dict	    =					{
    '''facebook/data2vec-vision-base-ft''': (
        '''https://huggingface.co/facebook/data2vec-vision-base-ft/resolve/main/config.json'''
    ),
}







class 		_snake_case  (				_snake_case							):
 SCREAMING_SNAKE_CASE__				=	'data2vec-vision'




 def __init__(		self ,  _lowerCamelCase=768 ,  _lowerCamelCase=12 ,  _lowerCamelCase=12 ,  _lowerCamelCase=3072 ,  _lowerCamelCase="gelu" ,  _lowerCamelCase=0.0 ,  _lowerCamelCase=0.0 ,  _lowerCamelCase=0.02 ,  _lowerCamelCase=1e-12 ,  _lowerCamelCase=224 ,  _lowerCamelCase=16 ,  _lowerCamelCase=3 ,  _lowerCamelCase=False ,  _lowerCamelCase=False ,  _lowerCamelCase=False ,  _lowerCamelCase=False ,  _lowerCamelCase=0.1 ,  _lowerCamelCase=0.1 ,  _lowerCamelCase=True ,  _lowerCamelCase=[3, 5, 7, 11] ,  _lowerCamelCase=[1, 2, 3, 6] ,  _lowerCamelCase=True ,  _lowerCamelCase=0.4 ,  _lowerCamelCase=256 ,  _lowerCamelCase=1 ,  _lowerCamelCase=False ,  _lowerCamelCase=255 ,  **_lowerCamelCase ,  ):
       super().__init__(**_lowerCamelCase   )

       a						:Tuple										=	hidden_size
       a						:Any										=	num_hidden_layers
       a						:Optional[int]										=	num_attention_heads
       a						:Dict										=	intermediate_size
       a						:List[Any]										=	hidden_act
       a						:List[str]										=	hidden_dropout_prob
       a						:Union[str, Any]										=	attention_probs_dropout_prob
       a						:Any										=	initializer_range
       a						:Any										=	layer_norm_eps

       a						:Union[str, Any]										=	image_size
       a						:int										=	patch_size
       a						:Optional[int]										=	num_channels
       a						:Union[str, Any]										=	use_mask_token
       a						:Optional[Any]										=	use_absolute_position_embeddings
       a						:Tuple										=	use_relative_position_bias
       a						:List[Any]										=	use_shared_relative_position_bias
       a						:Dict										=	layer_scale_init_value
       a						:Optional[int]										=	drop_path_rate
       a						:List[str]										=	use_mean_pooling
       # decode head attributes (semantic segmentation)
       a						:str										=	out_indices
       a						:Tuple										=	pool_scales
       # auxiliary head attributes (semantic segmentation)
       a						:List[Any]										=	use_auxiliary_head
       a						:List[Any]										=	auxiliary_loss_weight
       a						:Optional[int]										=	auxiliary_channels
       a						:List[str]										=	auxiliary_num_convs
       a						:str										=	auxiliary_concat_input
       a						:Union[str, Any]										=	semantic_loss_ignore_index







class 		_snake_case  (				_snake_case							):
 SCREAMING_SNAKE_CASE__				=	version.parse('1.11'							)




 @property
 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       return OrderedDict(
           [
               ('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}),
           ]   )




 @property
 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       return 1e-4





