





"""simple docstring"""







import logging
import os
import sys
from dataclasses import dataclass, field
from typing import Optional

from seqaseq_trainer import SeqaSeqTrainer
from seqaseq_training_args import SeqaSeqTrainingArguments

import transformers
from transformers import (
    AutoConfig,
    AutoModelForSeqaSeqLM,
    AutoTokenizer,
    HfArgumentParser,
    MBartTokenizer,
    MBartTokenizerFast,
    set_seed,
)
from transformers.trainer_utils import EvaluationStrategy, is_main_process
from transformers.training_args import ParallelMode
from utils import (
    SeqaSeqDataCollator,
    SeqaSeqDataset,
    assert_all_frozen,
    build_compute_metrics_fn,
    check_output_dir,
    freeze_embeds,
    freeze_params,
    lmap,
    save_json,
    use_task_specific_params,
    write_txt_file,
)


a__      :	List[Any]       				=      logging.getLogger(__name__)




@dataclass
class __magic_name__   :
       UpperCamelCase    :						str      =	field(
           metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"}		)
       UpperCamelCase    :						Optional[str]      =	field(
           default=__lowerCAmelCase    ,metadata={"help": "Pretrained config name or path if not the same as model_name"}		)
       UpperCamelCase    :						Optional[str]      =	field(
           default=__lowerCAmelCase    ,metadata={"help": "Pretrained tokenizer name or path if not the same as model_name"}		)
       UpperCamelCase    :						Optional[str]      =	field(
           default=__lowerCAmelCase    ,metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co"}    ,)
       UpperCamelCase    :						bool      =	field(default=__lowerCAmelCase    ,metadata={"help": "Whether tp freeze the encoder."}		)
       UpperCamelCase    :						bool      =	field(default=__lowerCAmelCase    ,metadata={"help": "Whether  to freeze the embeddings."}		)





@dataclass
class __magic_name__   :
       UpperCamelCase    :						str      =	field(
           metadata={"help": "The input data dir. Should contain the .tsv files (or other data files) for the task."}		)
       UpperCamelCase    :						Optional[str]      =	field(
           default="summarization"    ,metadata={"help": "Task name, summarization (or summarization_{dataset} for pegasus) or translation"}    ,)
       UpperCamelCase    :						Optional[int]      =	field(
           default=1_024    ,metadata={
               "help": (
                   "The maximum total input sequence length after tokenization. Sequences longer "
                   "than this will be truncated, sequences shorter will be padded."
               )
           }    ,)
       UpperCamelCase    :						Optional[int]      =	field(
           default=128    ,metadata={
               "help": (
                   "The maximum total sequence length for target text after tokenization. Sequences longer "
                   "than this will be truncated, sequences shorter will be padded."
               )
           }    ,)
       UpperCamelCase    :						Optional[int]      =	field(
           default=142    ,metadata={
               "help": (
                   "The maximum total sequence length for validation target text after tokenization. Sequences longer "
                   "than this will be truncated, sequences shorter will be padded. "
                   "This argument is also used to override the ``max_length`` param of ``model.generate``, which is used "
                   "during ``evaluate`` and ``predict``."
               )
           }    ,)
       UpperCamelCase    :						Optional[int]      =	field(
           default=142    ,metadata={
               "help": (
                   "The maximum total sequence length for test target text after tokenization. Sequences longer "
                   "than this will be truncated, sequences shorter will be padded."
               )
           }    ,)
       UpperCamelCase    :						Optional[int]      =	field(default=-1    ,metadata={"help": "# training examples. -1 means use all."}		)
       UpperCamelCase    :						Optional[int]      =	field(default=-1    ,metadata={"help": "# validation examples. -1 means use all."}		)
       UpperCamelCase    :						Optional[int]      =	field(default=-1    ,metadata={"help": "# test examples. -1 means use all."}		)
       UpperCamelCase    :						Optional[str]      =	field(default=__lowerCAmelCase    ,metadata={"help": "Source language id for translation."}		)
       UpperCamelCase    :						Optional[str]      =	field(default=__lowerCAmelCase    ,metadata={"help": "Target language id for translation."}		)
       UpperCamelCase    :						Optional[int]      =	field(default=__lowerCAmelCase    ,metadata={"help": "# num_beams to use for evaluation."}		)
       UpperCamelCase    :						bool      =	field(
           default=__lowerCAmelCase    ,metadata={"help": "If only pad tokens should be ignored. This assumes that `config.pad_token_id` is defined."}    ,)







def     A__			(       __lowerCamelCase,		__lowerCamelCase,		__lowerCamelCase					):





  """simple docstring"""
  logger.info(F'''***** {split} metrics *****'''					)
  for key in sorted(metrics.keys()					):
    logger.info(F'''  {key} = {metrics[key]}'''					)
  save_json(_snake_case,		os.path.join(_snake_case,		F'''{split}_results.json'''					)					)







def     A__			(       ):





  """simple docstring"""
  _lowerCAmelCase	      =					HfArgumentParser((ModelArguments, DataTrainingArguments, SeqaSeqTrainingArguments)					)

  if len(sys.argv					) == 2 and sys.argv[1].endswith('.json'					):
    # If we pass only one argument to the script and it's the path to a json file,
    # let's parse it to get our arguments.
    _lowerCAmelCase      ,   _lowerCAmelCase      ,   _lowerCAmelCase	      =					parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]					)					)
  else:
    _lowerCAmelCase      ,   _lowerCAmelCase      ,   _lowerCAmelCase	      =					parser.parse_args_into_dataclasses()

  check_output_dir(_snake_case					)

  # Setup logging
  logging.basicConfig(
      format='%(asctime)s - %(levelname)s - %(name)s - %(message)s',		datefmt='%m/%d/%Y %H:%M:%S',		level=logging.INFO if training_args.local_rank in [-1, 0] else logging.WARN,		)
  logger.warning(
      'Process rank: %s, device: %s, n_gpu: %s, distributed training: %s, 16-bits training: %s',		training_args.local_rank,		training_args.device,		training_args.n_gpu,		bool(training_args.parallel_mode == ParallelMode.DISTRIBUTED					),		training_args.fpaa,		)
  transformers.utils.logging.enable_default_handler()
  transformers.utils.logging.enable_explicit_format()
  # Set the verbosity to info of the Transformers logger (on main process only):
  if is_main_process(training_args.local_rank					):
    transformers.utils.logging.set_verbosity_info()
  logger.info('Training/evaluation parameters %s',		_snake_case					)

  # Set seed
  set_seed(training_args.seed					)

  # Load pretrained model and tokenizer
  #
  # Distributed training:
  # The .from_pretrained methods guarantee that only one local process can concurrently
  # download model & vocab.

  _lowerCAmelCase	      =					AutoConfig.from_pretrained(
      model_args.config_name if model_args.config_name else model_args.model_name_or_path,		cache_dir=model_args.cache_dir,		)

  _lowerCAmelCase	      =					('encoder_layerdrop', 'decoder_layerdrop', 'dropout', 'attention_dropout')
  for p in extra_model_params:
    if getattr(_snake_case,		_snake_case,		_snake_case					):
      assert hasattr(_snake_case,		_snake_case					), F'''({config.__class__.__name__}) doesn\'t have a `{p}` attribute'''
      setattr(_snake_case,		_snake_case,		getattr(_snake_case,		_snake_case					)					)

  _lowerCAmelCase	      =					AutoTokenizer.from_pretrained(
      model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path,		cache_dir=model_args.cache_dir,		)
  _lowerCAmelCase	      =					AutoModelForSeqaSeqLM.from_pretrained(
      model_args.model_name_or_path,		from_tf='.ckpt' in model_args.model_name_or_path,		config=_snake_case,		cache_dir=model_args.cache_dir,		)

  # use task specific params
  use_task_specific_params(_snake_case,		data_args.task					)

  # set num_beams for evaluation
  if data_args.eval_beams is None:
    _lowerCAmelCase	      =					model.config.num_beams

  # set decoder_start_token_id for MBart
  if model.config.decoder_start_token_id is None and isinstance(_snake_case,		(MBartTokenizer, MBartTokenizerFast)					):
    assert (
        data_args.tgt_lang is not None and data_args.src_lang is not None
    ), "mBart requires --tgt_lang and --src_lang"
    if isinstance(_snake_case,		_snake_case					):
      _lowerCAmelCase	      =					tokenizer.lang_code_to_id[data_args.tgt_lang]
    else:
      _lowerCAmelCase	      =					tokenizer.convert_tokens_to_ids(data_args.tgt_lang					)

  if model_args.freeze_embeds:
    freeze_embeds(_snake_case					)
  if model_args.freeze_encoder:
    freeze_params(model.get_encoder()					)
    assert_all_frozen(model.get_encoder()					)

  _lowerCAmelCase	      =					SeqaSeqDataset

  # Get datasets
  _lowerCAmelCase	      =					(
      dataset_class(
          _snake_case,		type_path='train',		data_dir=data_args.data_dir,		n_obs=data_args.n_train,		max_target_length=data_args.max_target_length,		max_source_length=data_args.max_source_length,		prefix=model.config.prefix or '',		)
      if training_args.do_train
      else None
  )
  _lowerCAmelCase	      =					(
      dataset_class(
          _snake_case,		type_path='val',		data_dir=data_args.data_dir,		n_obs=data_args.n_val,		max_target_length=data_args.val_max_target_length,		max_source_length=data_args.max_source_length,		prefix=model.config.prefix or '',		)
      if training_args.do_eval or training_args.evaluation_strategy != EvaluationStrategy.NO
      else None
  )
  _lowerCAmelCase	      =					(
      dataset_class(
          _snake_case,		type_path='test',		data_dir=data_args.data_dir,		n_obs=data_args.n_test,		max_target_length=data_args.test_max_target_length,		max_source_length=data_args.max_source_length,		prefix=model.config.prefix or '',		)
      if training_args.do_predict
      else None
  )

  # Initialize our Trainer
  _lowerCAmelCase	      =					(
      build_compute_metrics_fn(data_args.task,		_snake_case					) if training_args.predict_with_generate else None
  )
  _lowerCAmelCase	      =					SeqaSeqTrainer(
      model=_snake_case,		args=_snake_case,		data_args=_snake_case,		train_dataset=_snake_case,		eval_dataset=_snake_case,		data_collator=SeqaSeqDataCollator(
          _snake_case,		_snake_case,		model.config.decoder_start_token_id,		training_args.tpu_num_cores					),		compute_metrics=_snake_case,		tokenizer=_snake_case,		)

  _lowerCAmelCase	      =					{}
  # Training
  if training_args.do_train:
    logger.info('*** Train ***'					)

    _lowerCAmelCase	      =					trainer.train(
        model_path=model_args.model_name_or_path if os.path.isdir(model_args.model_name_or_path					) else None					)
    _lowerCAmelCase	      =					train_result.metrics
    _lowerCAmelCase	      =					data_args.n_train

    trainer.save_model()  # this also saves the tokenizer

    if trainer.is_world_process_zero():
      handle_metrics('train',		_snake_case,		training_args.output_dir					)
      all_metrics.update(_snake_case					)

      # Need to save the state, since Trainer.save_model saves only the tokenizer with the model
      trainer.state.save_to_json(os.path.join(training_args.output_dir,		'trainer_state.json'					)					)

      # For convenience, we also re-save the tokenizer to the same directory,
      # so that you can share your model easily on huggingface.co/models =)
      tokenizer.save_pretrained(training_args.output_dir					)

    # Evaluation
  if training_args.do_eval:
    logger.info('*** Evaluate ***'					)

    _lowerCAmelCase	      =					trainer.evaluate(metric_key_prefix='val'					)
    _lowerCAmelCase	      =					data_args.n_val
    _lowerCAmelCase	      =					round(metrics['val_loss'],		4					)

    if trainer.is_world_process_zero():
      handle_metrics('val',		_snake_case,		training_args.output_dir					)
      all_metrics.update(_snake_case					)

  if training_args.do_predict:
    logger.info('*** Predict ***'					)

    _lowerCAmelCase	      =					trainer.predict(test_dataset=_snake_case,		metric_key_prefix='test'					)
    _lowerCAmelCase	      =					test_output.metrics
    _lowerCAmelCase	      =					data_args.n_test

    if trainer.is_world_process_zero():
      _lowerCAmelCase	      =					round(metrics['test_loss'],		4					)
      handle_metrics('test',		_snake_case,		training_args.output_dir					)
      all_metrics.update(_snake_case					)

      if training_args.predict_with_generate:
        _lowerCAmelCase	      =					tokenizer.batch_decode(
            test_output.predictions,		skip_special_tokens=_snake_case,		clean_up_tokenization_spaces=_snake_case					)
        _lowerCAmelCase	      =					lmap(str.strip,		_snake_case					)
        write_txt_file(_snake_case,		os.path.join(training_args.output_dir,		'test_generations.txt'					)					)

  if trainer.is_world_process_zero():
    save_json(_snake_case,		os.path.join(training_args.output_dir,		'all_results.json'					)					)

  return all_metrics







def     A__			(       __lowerCamelCase					):





  """simple docstring"""
  main()


if __name__ == "__main__":
   main()









"""simple docstring"""

import math
from datetime import datetime, timedelta






def 		_snake_case	(   _snake_case				:   int				)       ->   datetime:






      '''simple docstring'''


      _A     =  year % 19
      _A     =  year % 4
      _A     =  year % 7
      _A     =  math.floor(year / 1_00				)
      _A     =  math.floor((13 + 8 * leap_day_inhibits) / 25				)
      _A     =  leap_day_inhibits / 4
      _A     =  (
          15 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
      ) % 30
      _A     =  (4 + leap_day_inhibits - leap_day_reinstall_number) % 7

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

      # PHM -> Paschal Full Moon
      _A     =  (
          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 (1_994, 2_000, 2_010, 2_021, 2_023):
              a							      =     '''will be''' if year > datetime.now().year else '''was'''
              print(F'''Easter in {year} {tense} {gauss_easter(year)}''')

