



__UpperCAmelCase			  =			[4, 1, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
__UpperCAmelCase			  =			[3, 7, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
__UpperCAmelCase			  =			{
    0: '''Sunday''',
    1: '''Monday''',
    2: '''Tuesday''',
    3: '''Wednesday''',
    4: '''Thursday''',
    5: '''Friday''',
    6: '''Saturday''',
}
def 						UpperCamelCase      (  snake_case__			:       int			,	snake_case__			:       int			,	snake_case__			:       int      )      ->	str:
   assert len(str(snake_case__      )      ) > 2, "year should be in YYYY format"
   assert 1 <= month <= 12, "month should be between 1 to 12"
   assert 1 <= day <= 31, "day should be between 1 to 31"

   # Doomsday algorithm:
   UpperCamelCase       :    Dict		      =      year // 100
   UpperCamelCase       :    Optional[Any]		      =      (5 * (century % 4) + 2) % 7
   UpperCamelCase       :    Union[str, Any]		      =      year % 100
   UpperCamelCase       :    Dict		      =      centurian % 12
   UpperCamelCase       :    Optional[int]		      =      (
       (centurian // 12) + centurian_m + (centurian_m // 4) + century_anchor
   ) % 7
   UpperCamelCase       :    Tuple		      =      (
       DOOMSDAY_NOT_LEAP[month - 1]
       if (year % 4 != 0) or (centurian == 0 and (year % 400) == 0)
       else DOOMSDAY_LEAP[month - 1]
   )
   UpperCamelCase       :    Tuple		      =      (dooms_day + day - day_anchor) % 7
   return WEEK_DAY_NAMES[week_day]


if __name__ == "__main__":
    import doctest

    doctest.testmod()










import argparse

import torch

from transformers import RemBertConfig, RemBertModel, load_tf_weights_in_rembert
from transformers.utils import logging


logging.set_verbosity_info()


def       UpperCamelCase__(			UpperCamelCase__     :			Any					,	UpperCamelCase__     :			int					,	UpperCamelCase__     :			List[Any]    )->Optional[int]:
       # Initialise PyTorch model
       A__		   =		RemBertConfig.from_json_file(UpperCamelCase__    )
       print('''Building PyTorch model from configuration: {}'''.format(str(UpperCamelCase__    )    )    )
       A__		   =		RemBertModel(UpperCamelCase__    )

       # Load weights from tf checkpoint
       load_tf_weights_in_rembert(UpperCamelCase__					,	UpperCamelCase__					,	UpperCamelCase__    )

       # Save pytorch-model
       print('''Save PyTorch model to {}'''.format(UpperCamelCase__    )    )
       torch.save(model.state_dict()					,	UpperCamelCase__    )


if __name__ == "__main__":
       a__: List[Any]							   =						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(
           '--rembert_config_file',
           default=None,
           type=str,
           required=True,
           help=(
               'The config json file corresponding to the pre-trained RemBERT 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.'
       )
       a__: Union[str, Any]							   =						parser.parse_args()
       convert_rembert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.rembert_config_file, args.pytorch_dump_path)





