

import argparse
import os
import re

import packaging.version


UpperCamelCase__		 =     '''examples/'''
UpperCamelCase__		 =     {
    '''examples''': (re.compile(r'''^check_min_version\("[^"]+"\)\s*$''', re.MULTILINE), '''check_min_version("VERSION")\n'''),
    '''init''': (re.compile(r'''^__version__\s+=\s+"([^"]+)"\s*$''', re.MULTILINE), '''__version__ = "VERSION"\n'''),
    '''setup''': (re.compile(r'''^(\s*)version\s*=\s*"[^"]+",''', re.MULTILINE), r'''\1version="VERSION",'''),
    '''doc''': (re.compile(r'''^(\s*)release\s*=\s*"[^"]+"$''', re.MULTILINE), '''release = "VERSION"\n'''),
}
UpperCamelCase__		 =     {
    '''init''': '''src/transformers/__init__.py''',
    '''setup''': '''setup.py''',
}
UpperCamelCase__		 =     '''README.md'''







def 						lowerCamelCase__      ( __A    :List[str]	,__A    :int	,__A    :Optional[Any]		):


       """simple docstring"""




       with open(__A	,"""r"""	,encoding="""utf-8"""	,newline="""\n"""		) as f:
              __snake_case       	=							f.read()
       __snake_case	,    __snake_case       	=							REPLACE_PATTERNS[pattern]
       __snake_case       	=							replace.replace("""VERSION"""	,__A		)
       __snake_case       	=							re_pattern.sub(__A	,__A		)
       with open(__A	,"""w"""	,encoding="""utf-8"""	,newline="""\n"""		) as f:
              f.write(__A		)







def 						lowerCamelCase__      ( __A    :Any		):


       """simple docstring"""




       for folder, directories, fnames in os.walk(__A		):
              # Removing some of the folders with non-actively maintained examples from the walk
              if "research_projects" in directories:
                     directories.remove("""research_projects"""		)
              if "legacy" in directories:
                     directories.remove("""legacy"""		)
              for fname in fnames:
                     if fname.endswith(""".py"""		):
                            update_version_in_file(os.path.join(__A	,__A		)	,__A	,pattern="""examples"""		)







def 						lowerCamelCase__      ( __A    :int	,__A    :Any=False		):


       """simple docstring"""




       for pattern, fname in REPLACE_FILES.items():
              update_version_in_file(__A	,__A	,__A		)
       if not patch:
              update_version_in_examples(__A		)







def 						lowerCamelCase__      ( ):


       """simple docstring"""




       __snake_case       	=							"""🤗 Transformers currently provides the following architectures"""
       __snake_case       	=							"""1. Want to contribute a new model?"""
       with open(__A	,"""r"""	,encoding="""utf-8"""	,newline="""\n"""		) as f:
              __snake_case       	=							f.readlines()

       # Find the start of the list.
       __snake_case       	=							0
       while not lines[start_index].startswith(_start_prompt		):
              start_index += 1
       start_index += 1

       __snake_case       	=							start_index
       # Update the lines in the model list.
       while not lines[index].startswith(_end_prompt		):
              if lines[index].startswith("""1."""		):
                     __snake_case       	=							lines[index].replace(
                         """https://huggingface.co/docs/transformers/main/model_doc"""	,"""https://huggingface.co/docs/transformers/model_doc"""	,)
              index += 1

       with open(__A	,"""w"""	,encoding="""utf-8"""	,newline="""\n"""		) as f:
              f.writelines(__A		)







def 						lowerCamelCase__      ( ):


       """simple docstring"""




       with open(REPLACE_FILES["""init"""]	,"""r"""		) as f:
              __snake_case       	=							f.read()
       __snake_case       	=							REPLACE_PATTERNS["""init"""][0].search(__A		).groups()[0]
       return packaging.version.parse(__A		)







def 						lowerCamelCase__      ( __A    :Any=False		):


       """simple docstring"""




       __snake_case       	=							get_version()
       if patch and default_version.is_devrelease:
              raise ValueError("""Can't create a patch version from the dev branch, checkout a released version!"""		)
       if default_version.is_devrelease:
              __snake_case       	=							default_version.base_version
       elif patch:
              __snake_case       	=							F'{default_version.major}.{default_version.minor}.{default_version.micro + 1}'
       else:
              __snake_case       	=							F'{default_version.major}.{default_version.minor + 1}.0'

       # Now let's ask nicely if that's the right one.
       __snake_case       	=							input(F'Which version are you releasing? [{default_version}]'		)
       if len(__A		) == 0:
              __snake_case       	=							default_version

       print(F'Updating version to {version}.'		)
       global_version_update(__A	,patch=__A		)
       if not patch:
              print("""Cleaning main README, don't forget to run `make fix-copies`."""		)
              clean_main_ref_in_model_list()







def 						lowerCamelCase__      ( ):


       """simple docstring"""




       __snake_case       	=							get_version()
       __snake_case       	=							F'{current_version.major}.{current_version.minor + 1}.0.dev0'
       __snake_case       	=							current_version.base_version

       # Check with the user we got that right.
       __snake_case       	=							input(F'Which version are we developing now? [{dev_version}]'		)
       if len(__A		) == 0:
              __snake_case       	=							dev_version

       print(F'Updating version to {version}.'		)
       global_version_update(__A		)
       print("""Cleaning main README, don't forget to run `make fix-copies`."""		)
       clean_main_ref_in_model_list()


if __name__ == "__main__":
    UpperCamelCase__		 =     argparse.ArgumentParser()
    parser.add_argument('''--post_release''', action='''store_true''', help='''Whether this is pre or post release.''')
    parser.add_argument('''--patch''', action='''store_true''', help='''Whether or not this is a patch release.''')
    UpperCamelCase__		 =     parser.parse_args()
    if not args.post_release:
        pre_release_work(patch=args.patch)
    elif args.patch:
        print('''Nothing to do after a patch :-)''')
    else:
        post_release_work()




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

import numpy as np
from utils_multiple_choice import MultipleChoiceDataset, Split, processors

import transformers
from transformers import (
    AutoConfig,
    AutoModelForMultipleChoice,
    AutoTokenizer,
    DataCollatorWithPadding,
    EvalPrediction,
    HfArgumentParser,
    Trainer,
    TrainingArguments,
    set_seed,
)
from transformers.trainer_utils import is_main_process


UpperCamelCase__		 =     logging.getLogger(__name__)







def 						lowerCamelCase__      ( __A    :Optional[int]	,__A    :str		):


       """simple docstring"""




       return (preds == labels).mean()

@dataclass
class     __snake_case    :
       """simple docstring"""







       __SCREAMING_SNAKE_CASE				    =							field(
           metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"}  )
       __SCREAMING_SNAKE_CASE				    =							field(
           default=snake_case__			,	metadata={"help": "Pretrained config name or path if not the same as model_name"}  )
       __SCREAMING_SNAKE_CASE				    =							field(
           default=snake_case__			,	metadata={"help": "Pretrained tokenizer name or path if not the same as model_name"}  )
       __SCREAMING_SNAKE_CASE				    =							field(
           default=snake_case__			,	metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co"}			,	)






@dataclass
class     __snake_case    :
       """simple docstring"""







       __SCREAMING_SNAKE_CASE				    =							field(metadata={"help": "The name of the task to train on: " + ", ".join(processors.keys()  )}  )
       __SCREAMING_SNAKE_CASE				    =							field(metadata={"help": "Should contain the data files for the task."}  )
       __SCREAMING_SNAKE_CASE				    =							field(
           default=1_28			,	metadata={
               "help": (
                   "The maximum total input sequence length after tokenization. Sequences longer "
                   "than this will be truncated, sequences shorter will be padded."
               )
           }			,	)
       __SCREAMING_SNAKE_CASE				    =							field(
           default=snake_case__			,	metadata={"help": "Overwrite the cached training and evaluation sets"}  )







def 						lowerCamelCase__      ( ):


       """simple docstring"""




       __snake_case       	=							HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)		)
       __snake_case	,    __snake_case	,    __snake_case       	=							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"""	,__A		)

       # Set seed
       set_seed(training_args.seed		)

       try:
              __snake_case       	=							processors[data_args.task_name]()
              __snake_case       	=							processor.get_labels()
              __snake_case       	=							len(__A		)
       except KeyError:
              raise ValueError("""Task not found: %s""" % (data_args.task_name)		)

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

       __snake_case       	=							AutoConfig.from_pretrained(
           model_args.config_name if model_args.config_name else model_args.model_name_or_path	,num_labels=__A	,finetuning_task=data_args.task_name	,cache_dir=model_args.cache_dir	,)
       __snake_case       	=							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	,)
       __snake_case       	=							AutoModelForMultipleChoice.from_pretrained(
           model_args.model_name_or_path	,from_tf=bool(""".ckpt""" in model_args.model_name_or_path		)	,config=__A	,cache_dir=model_args.cache_dir	,)

       # Get datasets
       __snake_case       	=							(
           MultipleChoiceDataset(
               data_dir=data_args.data_dir	,tokenizer=__A	,task=data_args.task_name	,max_seq_length=data_args.max_seq_length	,overwrite_cache=data_args.overwrite_cache	,mode=Split.train	,)
           if training_args.do_train
           else None
       )
       __snake_case       	=							(
           MultipleChoiceDataset(
               data_dir=data_args.data_dir	,tokenizer=__A	,task=data_args.task_name	,max_seq_length=data_args.max_seq_length	,overwrite_cache=data_args.overwrite_cache	,mode=Split.dev	,)
           if training_args.do_eval
           else None
       )

       def compute_metrics(__A    :EvalPrediction		) -> Dict:
              __snake_case       	=							np.argmax(p.predictions	,axis=1		)
              return {"acc": simple_accuracy(__A	,p.label_ids		)}

       # Data collator
       __snake_case       	=							DataCollatorWithPadding(__A	,pad_to_multiple_of=8		) if training_args.fpaa else None

       # Initialize our Trainer
       __snake_case       	=							Trainer(
           model=__A	,args=__A	,train_dataset=__A	,eval_dataset=__A	,compute_metrics=__A	,data_collator=__A	,)

       # 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		)

    # Evaluation
       __snake_case       	=							{}
       if training_args.do_eval:
              logger.info("""*** Evaluate ***"""		)

              __snake_case       	=							trainer.evaluate()

              __snake_case       	=							os.path.join(training_args.output_dir	,"""eval_results.txt"""		)
              if trainer.is_world_master():
                     with open(__A	,"""w"""		) as writer:
                            logger.info("""***** Eval results *****"""		)
                            for key, value in result.items():
                                   logger.info("""  %s = %s"""	,__A	,__A		)
                                   writer.write("""%s = %s\n""" % (key, value)		)

                            results.update(__A		)

       return results







def 						lowerCamelCase__      ( __A    :str		):


       """simple docstring"""




       main()


if __name__ == "__main__":
    main()

