





"""simple docstring"""





import argparse
import datetime


def       lowerCamelCase_       (   UpperCAmelCase_  )						->str:





  """simple docstring"""


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

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

  # Validate
  if not 0 < len(UpperCAmelCase_  ) < 11:
    raise ValueError('''Must be 10 characters long'''  )

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

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

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

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

  # Get datetime obj for validation
  __UpperCAmelCase    :						Dict       =						datetime.date(int(UpperCAmelCase_  )  ,			int(UpperCAmelCase_  )  ,			int(UpperCAmelCase_  )  )

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


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  lowercase__				:int				   =       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__				:Optional[int]				   =       parser.parse_args()
  zeller(args.date_input)






"""simple docstring"""





from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowercase__				:int				   =       logging.get_logger(__name__)

lowercase__				:List[str]				   =       {
    'EleutherAI/gpt-neox-20b': 'https://huggingface.co/EleutherAI/gpt-neox-20b/resolve/main/config.json',
    # See all GPTNeoX models at https://huggingface.co/models?filter=gpt_neox
}




class 							snake_case							(			__UpperCAmelCase ):

      '''simple docstring'''



      _A     :       List[Any]         =       'gpt_neox'

      def __init__(							self       :      Union[str, Any]						,				__lowercase       :      Any=50_432						,				__lowercase       :      int=6_144						,				__lowercase       :      List[str]=44						,				__lowercase       :      List[Any]=64						,				__lowercase       :      int=24_576						,				__lowercase       :      List[str]="gelu"						,				__lowercase       :      Optional[int]=0.2_5						,				__lowercase       :      Any=10_000						,				__lowercase       :      Union[str, Any]=0.0						,				__lowercase       :      List[str]=0.0						,				__lowercase       :      Union[str, Any]=0.1						,				__lowercase       :      Optional[int]=2_048						,				__lowercase       :      Union[str, Any]=0.0_2						,				__lowercase       :      Optional[int]=1e-5						,				__lowercase       :      str=True						,				__lowercase       :      str=0						,				__lowercase       :      Tuple=2						,				__lowercase       :      Tuple=False						,				__lowercase       :      int=True						,				__lowercase       :      Any=None						,				**__lowercase       :      List[str]						,				):


        '''simple docstring'''




        super().__init__(bos_token_id=__lowercase						,				eos_token_id=__lowercase						,				**__lowercase )
        __UpperCAmelCase    :						int       =						vocab_size
        __UpperCAmelCase    :						Union[str, Any]       =						max_position_embeddings
        __UpperCAmelCase    :						List[str]       =						hidden_size
        __UpperCAmelCase    :						Tuple       =						num_hidden_layers
        __UpperCAmelCase    :						Any       =						num_attention_heads
        __UpperCAmelCase    :						Union[str, Any]       =						intermediate_size
        __UpperCAmelCase    :						str       =						hidden_act
        __UpperCAmelCase    :						str       =						rotary_pct
        __UpperCAmelCase    :						str       =						rotary_emb_base
        __UpperCAmelCase    :						Dict       =						attention_dropout
        __UpperCAmelCase    :						str       =						hidden_dropout
        __UpperCAmelCase    :						Any       =						classifier_dropout
        __UpperCAmelCase    :						Tuple       =						initializer_range
        __UpperCAmelCase    :						Any       =						layer_norm_eps
        __UpperCAmelCase    :						Optional[int]       =						use_cache
        __UpperCAmelCase    :						List[Any]       =						tie_word_embeddings
        __UpperCAmelCase    :						Any       =						use_parallel_residual
        __UpperCAmelCase    :						List[str]       =						rope_scaling
        self._rope_scaling_validation()

        if self.hidden_size % self.num_attention_heads != 0:
          raise ValueError(
              '''The hidden size is not divisble by the number of attention heads! Make sure to update them!''' )







      def       A_					(							self       :      int ):


        '''simple docstring'''




        if self.rope_scaling is None:
          return

        if not isinstance(self.rope_scaling						,				__lowercase ) or len(self.rope_scaling ) != 2:
          raise ValueError(
              '''`rope_scaling` must be a dictionary with with two fields, `name` and `factor`, '''
              f'''got {self.rope_scaling}''' )
        __UpperCAmelCase    :						Union[str, Any]       =						self.rope_scaling.get('''type'''						,				__lowercase )
        __UpperCAmelCase    :						List[Any]       =						self.rope_scaling.get('''factor'''						,				__lowercase )
        if rope_scaling_type is None or rope_scaling_type not in ["linear", "dynamic"]:
          raise ValueError(
              f'''`rope_scaling`\'s name field must be one of [\'linear\', \'dynamic\'], got {rope_scaling_type}''' )
        if rope_scaling_factor is None or not isinstance(__lowercase						,				__lowercase ) or rope_scaling_factor <= 1.0:
          raise ValueError(f'''`rope_scaling`\'s factor field must be an float > 1, got {rope_scaling_factor}''' )