import argparse
import datetime

def    SCREAMING_SNAKE_CASE_     (						snake_case__							)     ->	Optional[Any]:
							lowerCAmelCase			=		{
							    '''0''': '''Sunday''',
							    '''1''': '''Monday''',
							    '''2''': '''Tuesday''',
							    '''3''': '''Wednesday''',
							    '''4''': '''Thursday''',
							    '''5''': '''Friday''',
							    '''6''': '''Saturday''',
							}

							lowerCAmelCase			=		{0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 6, 6: 0}

							# Validate
							if not 0 < len(__A							) < 1_1:
														raise ValueError('''Must be 10 characters long'''							)

							# Get month
							lowerCAmelCase			=		int(date_input[0] + date_input[1]							)
							# Validate
							if not 0 < m < 1_3:
														raise ValueError('''Month must be between 1 - 12'''							)

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

							# Get day
							lowerCAmelCase			=		int(date_input[3] + date_input[4]							)
							# Validate
							if not 0 < d < 3_2:
														raise ValueError('''Date must be between 1 - 31'''							)

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

							# Get year
							lowerCAmelCase			=		int(date_input[6] + date_input[7] + date_input[8] + date_input[9]							)
							# Arbitrary year range
							if not 4_5 < y < 8_5_0_0:
														raise ValueError(
														    '''Year out of range. There has to be some sort of limit...right?'''							)

							# Get datetime obj for validation
							lowerCAmelCase			=		datetime.date(int(__A							)   ,  int(__A							)   ,  int(__A							)							)

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


if __name__ == "__main__":
	import doctest

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








'''simple docstring'''





from collections import OrderedDict
from typing import Any, List, Mapping, Optional

from ... import PreTrainedTokenizer, TensorType, is_torch_available
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfigWithPast, PatchingSpec
from ...utils import logging


lowercase_		       =  logging.get_logger(__name__)

lowercase_		       =  {
    "EleutherAI/gpt-j-6B": "https://huggingface.co/EleutherAI/gpt-j-6B/resolve/main/config.json",
    # See all GPT-J models at https://huggingface.co/models?filter=gpt_j
}






class __A			(  A						):



 '''simple docstring'''







 __lowerCamelCase    :       Any          =       'gptj'
 __lowerCamelCase    :       List[str]          =       {
     'max_position_embeddings': 'n_positions',
     'hidden_size': 'n_embd',
     'num_attention_heads': 'n_head',
     'num_hidden_layers': 'n_layer',
 }



 def __init__(self ,   A=50_400 ,   A=2_048 ,   A=4_096 ,   A=28 ,   A=16 ,   A=64 ,   A=None ,   A="gelu_new" ,   A=0.0 ,   A=0.0 ,   A=0.0 ,   A=1E-5 ,   A=0.02 ,   A=True ,   A=50_256 ,   A=50_256 ,   A=False ,   **A ,   )    ->     Tuple:


      """simple docstring"""



      _a      =  vocab_size
      _a      =  n_positions
      _a      =  n_embd
      _a      =  n_layer
      _a      =  n_head
      _a      =  n_inner
      _a      =  rotary_dim
      _a      =  activation_function
      _a      =  resid_pdrop
      _a      =  embd_pdrop
      _a      =  attn_pdrop
      _a      =  layer_norm_epsilon
      _a      =  initializer_range
      _a      =  use_cache

      _a      =  bos_token_id
      _a      =  eos_token_id

      super().__init__(
          bos_token_id=A ,   eos_token_id=A ,   tie_word_embeddings=A ,   **A       )






class __A			(  A						):



 '''simple docstring'''







 def __init__(self ,   A ,   A = "default" ,   A = None ,   A = False ,   )    ->     List[str]:


      """simple docstring"""



      super().__init__(A ,   task=A ,   patching_specs=A ,   use_past=A       )
      if not getattr(self._config ,   '''pad_token_id''' ,   A       ):
           # TODO: how to do that better?
           _a      =  0



 @property
 def 					a__  (self       )    ->     Mapping[str, Mapping[int, str]]:


      """simple docstring"""



      _a      =  OrderedDict({'''input_ids''': {0: '''batch''', 1: '''sequence'''}}       )
      if self.use_past:
           self.fill_with_past_key_values_(A ,   direction='''inputs'''       )
           _a      =  {0: '''batch''', 1: '''past_sequence + sequence'''}
      else:
           _a      =  {0: '''batch''', 1: '''sequence'''}

      return common_inputs



 @property
 def 					a__  (self       )    ->     int:


      """simple docstring"""



      return self._config.n_layer



 @property
 def 					a__  (self       )    ->     int:


      """simple docstring"""



      return self._config.n_head



 def 					a__  (self ,   A ,   A = -1 ,   A = -1 ,   A = False ,   A = None ,   )    ->     Mapping[str, Any]:


      """simple docstring"""



      _a      =  super(A ,   self       ).generate_dummy_inputs(
          A ,   batch_size=A ,   seq_length=A ,   is_pair=A ,   framework=A       )

      # We need to order the input in the way they appears in the forward()
      _a      =  OrderedDict({'''input_ids''': common_inputs['''input_ids''']}       )

      # Need to add the past_keys
      if self.use_past:
           if not is_torch_available():
                raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.'''       )
           else:
                import torch

                _a  ,    _a      =  common_inputs['''input_ids'''].shape
                # Not using the same length for past_key_values
                _a      =  seqlen + 2
                _a      =  (
                    batch,
                    self.num_attention_heads,
                    past_key_values_length,
                    self._config.hidden_size // self.num_attention_heads,
                )
                _a      =  [
                    (torch.zeros(A       ), torch.zeros(A       )) for _ in range(self.num_layers       )
                ]

      _a      =  common_inputs['''attention_mask''']
      if self.use_past:
           _a      =  ordered_inputs['''attention_mask'''].dtype
           _a      =  torch.cat(
               [ordered_inputs['''attention_mask'''], torch.ones(A ,   A ,   dtype=A       )] ,   dim=1       )

      return ordered_inputs



 @property
 def 					a__  (self       )    ->     int:


      """simple docstring"""



      return 13



