





import math
from datetime import datetime, timedelta



def 				lowerCAmelCase_ (							A_):
    UpperCamelCase__:	List[str]					=     year % 19
    UpperCamelCase__:	Union[str, Any]					=     year % 4
    UpperCamelCase__:	Optional[int]					=     year % 7
    UpperCamelCase__:	str					=     math.floor(year / 1_00)
    UpperCamelCase__:	Tuple					=     math.floor((13 + 8 * leap_day_inhibits) / 25)
    UpperCamelCase__:	str					=     leap_day_inhibits / 4
    UpperCamelCase__:	Union[str, Any]					=     (
        15 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
    ) % 30
    UpperCamelCase__:	int					=     (4 + leap_day_inhibits - leap_day_reinstall_number) % 7

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

    # PHM -> Paschal Full Moon
    UpperCamelCase__:	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(A_    ,4    ,19)
    elif days_to_add == 28 and days_from_phm_to_sunday == 6:
        return datetime(A_    ,4    ,18)
    else:
        return datetime(A_    ,3    ,22) + timedelta(
            days=int(days_to_add + days_from_phm_to_sunday))


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








import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto import CONFIG_MAPPING


A__:    str  	=	logging.get_logger(__name__)

A__:    Union[str, Any]  	=	{
    '''SenseTime/deformable-detr''': '''https://huggingface.co/sensetime/deformable-detr/resolve/main/config.json''',
    # See all Deformable DETR models at https://huggingface.co/models?filter=deformable-detr
}




class        _a    (    UpperCamelCase__):

      """simple docstring"""


      UpperCamelCase__  		=       """deformable_detr"""
      UpperCamelCase__  		=       {
          """hidden_size""": """d_model""",
          """num_attention_heads""": """encoder_attention_heads""",
      }






      def __init__(		self:			Dict	,    __lowerCamelCase:			Optional[Any]=True	,    __lowerCamelCase:			List[str]=None	,    __lowerCamelCase:			Tuple=3	,    __lowerCamelCase:			Union[str, Any]=300	,    __lowerCamelCase:			Optional[Any]=1024	,    __lowerCamelCase:			Optional[int]=6	,    __lowerCamelCase:			Optional[int]=1024	,    __lowerCamelCase:			List[str]=8	,    __lowerCamelCase:			Any=6	,    __lowerCamelCase:			Tuple=1024	,    __lowerCamelCase:			List[str]=8	,    __lowerCamelCase:			Optional[int]=0.0	,    __lowerCamelCase:			Union[str, Any]=True	,    __lowerCamelCase:			List[str]="relu"	,    __lowerCamelCase:			Tuple=256	,    __lowerCamelCase:			Dict=0.1	,    __lowerCamelCase:			Optional[Any]=0.0	,    __lowerCamelCase:			Optional[int]=0.0	,    __lowerCamelCase:			Any=0.02	,    __lowerCamelCase:			int=1.0	,    __lowerCamelCase:			Optional[Any]=True	,    __lowerCamelCase:			str=False	,    __lowerCamelCase:			Any="sine"	,    __lowerCamelCase:			Optional[Any]="resnet50"	,    __lowerCamelCase:			Optional[int]=True	,    __lowerCamelCase:			int=False	,    __lowerCamelCase:			int=4	,    __lowerCamelCase:			int=4	,    __lowerCamelCase:			Any=4	,    __lowerCamelCase:			Any=False	,    __lowerCamelCase:			List[str]=300	,    __lowerCamelCase:			Dict=False	,    __lowerCamelCase:			str=1	,    __lowerCamelCase:			int=5	,    __lowerCamelCase:			str=2	,    __lowerCamelCase:			Dict=1	,    __lowerCamelCase:			Tuple=1	,    __lowerCamelCase:			Union[str, Any]=5	,    __lowerCamelCase:			Optional[Any]=2	,    __lowerCamelCase:			List[str]=0.1	,    __lowerCamelCase:			Dict=0.25	,    __lowerCamelCase:			Dict=False	,    **__lowerCamelCase:			str	,    ):
          '''simple docstring'''


          if backbone_config is not None and use_timm_backbone:
              raise ValueError("You can't specify both `backbone_config` and `use_timm_backbone`."					)

          if not use_timm_backbone:
              if backbone_config is None:
                  logger.info("`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone."					)
                  UpperCamelCase__:	Union[str, Any]					=     CONFIG_MAPPING["resnet"](out_features=["stage4"]					)
              elif isinstance(__lowerCamelCase	,    __lowerCamelCase					):
                  UpperCamelCase__:	Tuple					=     backbone_config.get("model_type"					)
                  UpperCamelCase__:	Optional[int]					=     CONFIG_MAPPING[backbone_model_type]
                  UpperCamelCase__:	Tuple					=     config_class.from_dict(__lowerCamelCase					)
          UpperCamelCase__:	Dict					=     use_timm_backbone
          UpperCamelCase__:	Any					=     backbone_config
          UpperCamelCase__:	Optional[int]					=     num_channels
          UpperCamelCase__:	int					=     num_queries
          UpperCamelCase__:	List[str]					=     max_position_embeddings
          UpperCamelCase__:	Dict					=     d_model
          UpperCamelCase__:	List[Any]					=     encoder_ffn_dim
          UpperCamelCase__:	Union[str, Any]					=     encoder_layers
          UpperCamelCase__:	Tuple					=     encoder_attention_heads
          UpperCamelCase__:	Tuple					=     decoder_ffn_dim
          UpperCamelCase__:	Optional[int]					=     decoder_layers
          UpperCamelCase__:	int					=     decoder_attention_heads
          UpperCamelCase__:	Optional[Any]					=     dropout
          UpperCamelCase__:	List[str]					=     attention_dropout
          UpperCamelCase__:	List[Any]					=     activation_dropout
          UpperCamelCase__:	List[Any]					=     activation_function
          UpperCamelCase__:	Union[str, Any]					=     init_std
          UpperCamelCase__:	List[str]					=     init_xavier_std
          UpperCamelCase__:	Optional[Any]					=     encoder_layerdrop
          UpperCamelCase__:	List[str]					=     auxiliary_loss
          UpperCamelCase__:	Optional[int]					=     position_embedding_type
          UpperCamelCase__:	Optional[Any]					=     backbone
          UpperCamelCase__:	Any					=     use_pretrained_backbone
          UpperCamelCase__:	Union[str, Any]					=     dilation
          # deformable attributes
          UpperCamelCase__:	Union[str, Any]					=     num_feature_levels
          UpperCamelCase__:	Optional[Any]					=     encoder_n_points
          UpperCamelCase__:	Tuple					=     decoder_n_points
          UpperCamelCase__:	Any					=     two_stage
          UpperCamelCase__:	Optional[int]					=     two_stage_num_proposals
          UpperCamelCase__:	str					=     with_box_refine
          if two_stage is True and with_box_refine is False:
              raise ValueError("If two_stage is True, with_box_refine must be True."					)
          # Hungarian matcher
          UpperCamelCase__:	Any					=     class_cost
          UpperCamelCase__:	str					=     bbox_cost
          UpperCamelCase__:	List[str]					=     giou_cost
          # Loss coefficients
          UpperCamelCase__:	Optional[Any]					=     mask_loss_coefficient
          UpperCamelCase__:	List[Any]					=     dice_loss_coefficient
          UpperCamelCase__:	Optional[Any]					=     bbox_loss_coefficient
          UpperCamelCase__:	List[Any]					=     giou_loss_coefficient
          UpperCamelCase__:	Dict					=     eos_coefficient
          UpperCamelCase__:	List[Any]					=     focal_alpha
          UpperCamelCase__:	Dict					=     disable_custom_kernels
          super().__init__(is_encoder_decoder=__lowerCamelCase	,    **__lowerCamelCase					)






      @property
      def 			UpperCAmelCase_       (		self:			Union[str, Any]					):
          '''simple docstring'''


          return self.encoder_attention_heads






      @property
      def 			UpperCAmelCase_       (		self:			Any					):
          '''simple docstring'''


          return self.d_model






      def 			UpperCAmelCase_       (		self:			int					):
          '''simple docstring'''


          UpperCamelCase__:	Optional[int]					=     copy.deepcopy(self.__dict__					)
          if self.backbone_config is not None:
              UpperCamelCase__:	Tuple					=     self.backbone_config.to_dict()
          UpperCamelCase__:	Optional[int]					=     self.__class__.model_type
          return output

