
import math
from datetime import datetime, timedelta



def        UpperCamelCase    (							lowerCAmelCase__		):
					'''simple docstring'''
					lowercase							=						year % 19
					lowercase							=						year % 4
					lowercase							=						year % 7
					lowercase							=						math.floor(year / 100		)
					lowercase							=						math.floor((13 + 8 * leap_day_inhibits) / 25		)
					lowercase							=						leap_day_inhibits / 4
					lowercase							=						(
					    15 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
					) % 30
					lowercase							=						(4 + leap_day_inhibits - leap_day_reinstall_number) % 7

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

					# PHM -> Paschal Full Moon
					lowercase							=						(
					    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(snake_case__ ,			4 ,			19		)
					elif days_to_add == 28 and days_from_phm_to_sunday == 6:
										return datetime(snake_case__ ,			4 ,			18		)
					else:
										return datetime(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__		:Dict   =    "will be" if year > datetime.now().year else "was"
														print(F'Easter in {year} {tense} {gauss_easter(year)}')





import argparse

import torch

from ...utils import logging
from . import AlbertConfig, AlbertForPreTraining, load_tf_weights_in_albert


logging.set_verbosity_info()






def  snake_case  (       snake_case__			:int   ,	snake_case__			:List[str]   ,	snake_case__			:Union[str, Any])						->   str:
       # Initialise PyTorch model
       _A        =  AlbertConfig.from_json_file(snake_case__)
       print(F'''Building PyTorch model from configuration: {config}''')
       _A        =  AlbertForPreTraining(snake_case__)

       # Load weights from tf checkpoint
       load_tf_weights_in_albert(snake_case__   ,	snake_case__   ,	snake_case__)

       # Save pytorch-model
       print(F'''Save PyTorch model to {pytorch_dump_path}''')
       torch.save(model.state_dict()   ,	snake_case__)


if __name__ == "__main__":
    _SCREAMING_SNAKE_CASE										=						argparse.ArgumentParser()
    # Required parameters
    parser.add_argument(
        '--tf_checkpoint_path', default=None, type=str, required=True, help='Path to the TensorFlow checkpoint path.'
    )
    parser.add_argument(
        '--albert_config_file',
        default=None,
        type=str,
        required=True,
        help=(
            'The config json file corresponding to the pre-trained ALBERT model. \n'
            'This specifies the model architecture.'
        ),
    )
    parser.add_argument(
        '--pytorch_dump_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
    )
    _SCREAMING_SNAKE_CASE										=						parser.parse_args()
    convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.albert_config_file, args.pytorch_dump_path)




