



'''simple docstring'''






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


A_				:					int							=      logging.getLogger(__name__)



@dataclass
class 				lowercase			:


 """simple docstring"""


 UpperCAmelCase		      =    field(
     metadata={"""help""": """Path to pretrained model or model identifier from huggingface.co/models"""}							)
 UpperCAmelCase		      =    field(
     default=_lowerCamelCase   ,   metadata={"""help""": """Pretrained config name or path if not the same as model_name"""}							)
 UpperCAmelCase		      =    field(
     default=_lowerCamelCase   ,   metadata={"""help""": """Pretrained tokenizer name or path if not the same as model_name"""}							)
 UpperCAmelCase		      =    field(default=_lowerCamelCase   ,   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.
 UpperCAmelCase		      =    field(
     default=_lowerCamelCase   ,   metadata={"""help""": """Where do you want to store the pretrained models downloaded from huggingface.co"""}   ,   )







def        snake_case_   (	)->						Dict:





       '''simple docstring'''


       _UpperCAmelCase    :		Optional[Any]     	=					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.
              _UpperCAmelCase	,_UpperCAmelCase	,_UpperCAmelCase    :		str     	=					parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]						)						)
       else:
              _UpperCAmelCase	,_UpperCAmelCase	,_UpperCAmelCase    :		Optional[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.

       _UpperCAmelCase    :		Optional[Any]     	=					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			,  )
       _UpperCAmelCase    :		List[Any]     	=					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_			,  )
       _UpperCAmelCase    :		List[str]     	=					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
       _UpperCAmelCase    :		Tuple     	=					hasattr(model.config			,  """lang2id"""						)
       _UpperCAmelCase    :		Tuple     	=					(
           SquadDataset(
               lowerCAmelCase_			,  tokenizer=lowerCAmelCase_			,  is_language_sensitive=lowerCAmelCase_			,  cache_dir=model_args.cache_dir						)
           if training_args.do_train
           else None
       )
       _UpperCAmelCase    :		Optional[Any]     	=					(
           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
       _UpperCAmelCase    :		Optional[int]     	=					DataCollatorWithPadding(lowerCAmelCase_			,  pad_to_multiple_of=8						) if training_args.fpaa else None

       # Initialize our Trainer
       _UpperCAmelCase    :		Union[str, Any]     	=					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        snake_case_   (	lowerCAmelCase_						)->						Any:





       '''simple docstring'''


       main()


if __name__ == "__main__":
   main()








'''simple docstring'''






import itertools




def        snake_case_   (	lowerCAmelCase_						)->						Dict:





       '''simple docstring'''


       return (
           int("""""".join(combination[0:2]						)						) * int("""""".join(combination[2:5]						)						)
           == int("""""".join(combination[5:9]						)						)
       ) or (
           int("""""".join(combination[0]						)						) * int("""""".join(combination[1:5]						)						)
           == int("""""".join(combination[5:9]						)						)
       )




def        snake_case_   (	)->						str:





       '''simple docstring'''


       return sum(
           {
               int("""""".join(pandigital[5:9]						)						)
               for pandigital in itertools.permutations("""123456789"""						)
               if is_combination_valid(lowerCAmelCase_						)
           }						)


if __name__ == "__main__":
   print(solution())



