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

import transformers
from transformers import (
    AutoConfig,
    AutoModelForQuestionAnswering,
    AutoTokenizer,
    DataCollatorWithPadding,
    HfArgumentParser,
    SquadDataset,
    Trainer,
    TrainingArguments,
)
from transformers import SquadDataTrainingArguments as DataTrainingArguments
from transformers.trainer_utils import is_main_process


__lowerCamelCase							= logging.getLogger(__name__)






@dataclass
class 						UpperCAmelCase	:
   A__      :	str		  =  field(
       metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"}				)
   A__      :	Optional[str]		  =  field(
       default=A_ ,metadata={"help": "Pretrained config name or path if not the same as model_name"}				)
   A__      :	Optional[str]		  =  field(
       default=A_ ,metadata={"help": "Pretrained tokenizer name or path if not the same as model_name"}				)
   A__      :	bool		  =  field(default=A_ ,metadata={"help": "Set this flag to use fast tokenization."}				)
   # If you want to tweak more attributes on your tokenizer, you should do it in a distinct script,
   # or just modify its tokenizer_config.json.
   A__      :	Optional[str]		  =  field(
       default=A_ ,metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co"} ,)



def     UpperCamelCase      (					):
       # See all possible arguments in src/transformers/training_args.py
       # or by passing the --help flag to this script.
       # We now keep distinct sets of args, for a cleaner separation of concerns.

       snake_case :     List[str]           =   HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)					)

       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.
              snake_case       ,      snake_case       ,      snake_case :     List[Any]           =   parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]					)					)
       else:
              snake_case       ,      snake_case       ,      snake_case :     int           =   parser.parse_args_into_dataclasses()

       if (
           os.path.exists(training_args.output_dir					)
           and os.listdir(training_args.output_dir					)
           and training_args.do_train
           and not training_args.overwrite_output_dir
       ):
              raise ValueError(
                  f"""Output directory ({training_args.output_dir}) already exists and is not empty. Use"""
                  " --overwrite_output_dir to overcome."					)

       # 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.local_rank != -1					)       ,      training_args.fpaa       ,      )
       # 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()
              transformers.utils.logging.enable_default_handler()
              transformers.utils.logging.enable_explicit_format()
       logger.info("Training/evaluation parameters %s"       ,      __lowerCamelCase					)

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

       snake_case :     Tuple           =   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       ,      )
       snake_case :     Dict           =   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       ,      use_fast=__lowerCamelCase       ,      )
       snake_case :     Dict           =   AutoModelForQuestionAnswering.from_pretrained(
           model_args.model_name_or_path       ,      from_tf=bool(".ckpt" in model_args.model_name_or_path					)       ,      config=__lowerCamelCase       ,      cache_dir=model_args.cache_dir       ,      )

       # Get datasets
       snake_case :     List[str]           =   hasattr(model.config       ,      "lang2id"					)
       snake_case :     Optional[Any]           =   (
           SquadDataset(
               __lowerCamelCase       ,      tokenizer=__lowerCamelCase       ,      is_language_sensitive=__lowerCamelCase       ,      cache_dir=model_args.cache_dir					)
           if training_args.do_train
           else None
       )
       snake_case :     List[str]           =   (
           SquadDataset(
               __lowerCamelCase       ,      tokenizer=__lowerCamelCase       ,      mode="dev"       ,      is_language_sensitive=__lowerCamelCase       ,      cache_dir=model_args.cache_dir       ,      )
           if training_args.do_eval
           else None
       )

       # Data collator
       snake_case :     List[Any]           =   DataCollatorWithPadding(__lowerCamelCase       ,      pad_to_multiple_of=8					) if training_args.fpaa else None

       # Initialize our Trainer
       snake_case :     List[str]           =   Trainer(
           model=__lowerCamelCase       ,      args=__lowerCamelCase       ,      train_dataset=__lowerCamelCase       ,      eval_dataset=__lowerCamelCase       ,      data_collator=__lowerCamelCase       ,      )

       # Training
       if training_args.do_train:
              trainer.train(
                  model_path=model_args.model_name_or_path if os.path.isdir(model_args.model_name_or_path					) else None					)
              trainer.save_model()
              # For convenience, we also re-save the tokenizer to the same directory,
              # so that you can share your model easily on huggingface.co/models =)
              if trainer.is_world_master():
                     tokenizer.save_pretrained(training_args.output_dir					)


def     UpperCamelCase      (					__lowerCamelCase  :				Any					):
       # For xla_spawn (TPUs)
       main()


if __name__ == "__main__":
   main()







def     UpperCamelCase      (					__lowerCamelCase  :				int = 998001					):
       snake_case :     Optional[Any]           =   0
       for i in range(999       ,      99       ,      -1					):  # 3 digit numbers range from 999 down to 100
              for j in range(999       ,      99       ,      -1					):
                     snake_case :     Tuple           =   str(i * j					)
                     if product_string == product_string[::-1] and i * j < n:
                            snake_case :     str           =   max(__lowerCamelCase       ,      i * j					)
       return answer


if __name__ == "__main__":
   print(F'{solution() = }')





