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


lowercase  : Tuple						   =							logging.get_logger(__name__)

lowercase  : Union[str, Any]						   =							{}

class __snake_case		(				lowerCAmelCase					):
    _a		:						int=    "llama"
    _a		:						Union[str, Any]=    ["past_key_values"]
    def __init__(  self		,snake_case=32000		,snake_case=4096		,snake_case=11008		,snake_case=32		,snake_case=32		,snake_case=None		,snake_case="silu"		,snake_case=2048		,snake_case=0.02		,snake_case=1e-6		,snake_case=True		,snake_case=0		,snake_case=1		,snake_case=2		,snake_case=1		,snake_case=False		,snake_case=None		,**snake_case		,):



           '''simple docstring'''







           lowercase							:					List[Any]	     =				vocab_size
           lowercase							:					Dict	     =				max_position_embeddings
           lowercase							:					List[str]	     =				hidden_size
           lowercase							:					Union[str, Any]	     =				intermediate_size
           lowercase							:					int	     =				num_hidden_layers
           lowercase							:					Optional[int]	     =				num_attention_heads

           # for backward compatibility
           if num_key_value_heads is None:
                  lowercase							:					List[Any]	     =				num_attention_heads

           lowercase							:					Optional[Any]	     =				num_key_value_heads
           lowercase							:					int	     =				hidden_act
           lowercase							:					Optional[int]	     =				initializer_range
           lowercase							:					Dict	     =				rms_norm_eps
           lowercase							:					Tuple	     =				pretraining_tp
           lowercase							:					Union[str, Any]	     =				use_cache
           lowercase							:					Dict	     =				rope_scaling
           self._rope_scaling_validation()

           super().__init__(
               pad_token_id=snake_case		,bos_token_id=snake_case		,eos_token_id=snake_case		,tie_word_embeddings=snake_case		,**snake_case		,)
    def 				_SCREAMING_SNAKE_CASE	(  self				):



           '''simple docstring'''







           if self.rope_scaling is None:
                  return

           if not isinstance(self.rope_scaling		,snake_case				) 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}"				)
           lowercase							:					Optional[Any]	     =				self.rope_scaling.get("""type"""		,snake_case				)
           lowercase							:					Dict	     =				self.rope_scaling.get("""factor"""		,snake_case				)
           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(snake_case		,snake_case				) or rope_scaling_factor <= 1.0:
                  raise ValueError(f"`rope_scaling`'s factor field must be an float > 1, got {rope_scaling_factor}"				)


import math
from datetime import datetime, timedelta







def 						_snake_case(  SCREAMING_SNAKE_CASE__    )			->   datetime:
       lowercase							:					Any	     =				year % 19
       lowercase							:					Optional[int]	     =				year % 4
       lowercase							:					Any	     =				year % 7
       lowercase							:					str	     =				math.floor(year / 100    )
       lowercase							:					List[str]	     =				math.floor((13 + 8 * leap_day_inhibits) / 25    )
       lowercase							:					Tuple	     =				leap_day_inhibits / 4
       lowercase							:					Any	     =				(
           15 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
       ) % 30
       lowercase							:					Union[str, Any]	     =				(4 + leap_day_inhibits - leap_day_reinstall_number) % 7

       # days to be added to March 21
       lowercase							:					str	     =				(19 * metonic_cycle + secular_moon_shift) % 30

       # PHM -> Paschal Full Moon
       lowercase							:					List[Any]	     =				(
           2 * julian_leap_year
           + 4 * non_leap_year
           + 6 * days_to_add
           + century_starting_point
       ) % 7

       if days_to_add == 29 and days_from_phm_to_sunday == 6:
              return datetime(SCREAMING_SNAKE_CASE__ ,     4 ,     19    )
       elif days_to_add == 28 and days_from_phm_to_sunday == 6:
              return datetime(SCREAMING_SNAKE_CASE__ ,     4 ,     18    )
       else:
              return datetime(SCREAMING_SNAKE_CASE__ ,     3 ,     22    ) + timedelta(
                  days=int(days_to_add + days_from_phm_to_sunday    )    )


if __name__ == "__main__":
  for year in (1994, 2000, 2010, 2021, 2023):
    lowercase  : List[str]						   =							"""will be""" if year > datetime.now().year else """was"""
    print(F'''Easter in {year} {tense} {gauss_easter(year)}''')
