



'''simple docstring'''





import argparse
import datetime




def lowerCAmelCase  (__A):



     """simple docstring"""



     _a      =  {
         '''0''': '''Sunday''',
         '''1''': '''Monday''',
         '''2''': '''Tuesday''',
         '''3''': '''Wednesday''',
         '''4''': '''Thursday''',
         '''5''': '''Friday''',
         '''6''': '''Saturday''',
     }

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

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

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

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

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

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


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  lowercase_		       =  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_		       =  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



