"""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


lowerCAmelCase__    :    str			=      logging.getLogger(__name__)
@dataclass
class 							snake_case			:




					"""simple docstring"""

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






def     a_		(   ):
				# 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.

				UpperCAmelCase__			 =				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__			 =				parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]			)			)
				else:
								UpperCAmelCase__ ,      UpperCAmelCase__ ,      UpperCAmelCase__			 =				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__			 =				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__			 =				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__			 =				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__			 =				hasattr(model.config   ,     'lang2id'			)
				UpperCAmelCase__			 =				(
				    SquadDataset(
				        lowerCamelCase   ,     tokenizer=lowerCamelCase   ,     is_language_sensitive=lowerCamelCase   ,     cache_dir=model_args.cache_dir			)
				    if training_args.do_train
				    else None
				)
				UpperCAmelCase__			 =				(
				    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__			 =				DataCollatorWithPadding(lowerCamelCase   ,     pad_to_multiple_of=8			) if training_args.fpaa else None

				# Initialize our Trainer
				UpperCAmelCase__			 =				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     a_		(   lowerCamelCase			):
				# For xla_spawn (TPUs)
				main()


if __name__ == "__main__":
						main()




"""simple docstring"""






import os
import unittest

import pytest
from parameterized import parameterized

from transformers.testing_utils import require_torch, require_torch_gpu, slow, torch_device


# skipping in unittest tests

lowerCAmelCase__    :    Union[str, Any]			=      [(1,)]



def     a_		(   ):
				UpperCAmelCase__			 =				bool(os.getenv('RUN_SLOW'   ,     0			)			)
				if run_slow:
								assert True
				else:
								assert False, "should have been skipped"



def     a_		(   ):
				UpperCAmelCase__			 =				bool(os.getenv('RUN_SLOW'   ,     0			)			)
				if run_slow and torch_device == "cuda":
								assert True
				else:
								assert False, "should have been skipped"
@require_torch
class 							snake_case			(					unittest.TestCase							):




					"""simple docstring"""

					@slow
					@require_torch_gpu
					def 						__lowerCAmelCase		(							self  :      Optional[Any]     ):
									check_slow_torch_cuda()







					@require_torch_gpu
					@slow
					def 						__lowerCAmelCase		(							self  :      Any     ):
									check_slow_torch_cuda()







					@parameterized.expand(lowerCamelCase__     )
					@slow
					def 						__lowerCAmelCase		(							self  :      Union[str, Any]       ,lowerCamelCase__  :      str=None     ):
									check_slow()






@slow
@require_torch_gpu
def     a_		(   ):
				check_slow_torch_cuda()



@require_torch_gpu
@slow
def     a_		(   ):
				check_slow_torch_cuda()



@slow
@pytest.mark.parametrize('param'   ,     [1]			)
def     a_		(   lowerCamelCase			):
				check_slow()







@pytest.mark.parametrize('param'   ,     [1]			)
@slow
def     a_		(   lowerCamelCase			):
				check_slow()



