






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 				_UpperCAmelCase :

				"""simple docstring"""




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






def   a      (						):






				'''simple docstring'''
				# 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.

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

				lowercase__       			=      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		,       )
				lowercase__       			=      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_		,       )
				lowercase__       			=      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
				lowercase__       			=      hasattr(model.config		,       '''lang2id'''    )
				lowercase__       			=      (
				    SquadDataset(
				        lowerCamelCase_		,       tokenizer=lowerCamelCase_		,       is_language_sensitive=lowerCamelCase_		,       cache_dir=model_args.cache_dir    )
				    if training_args.do_train
				    else None
				)
				lowercase__       			=      (
				    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
				lowercase__       			=      DataCollatorWithPadding(lowerCamelCase_		,       pad_to_multiple_of=8    ) if training_args.fpaa else None

				# Initialize our Trainer
				lowercase__       			=      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_    ):






				'''simple docstring'''
				# For xla_spawn (TPUs)
				main()


if __name__ == "__main__":
							main()












import dataclasses
import enum
import functools
import math
import re

# The following script is adapted from the script of TaPas.
# Original: https://github.com/google-research/tapas/master/wikisql_utils.py
from typing import Any, List, Text


A__     :      Dict             =			'none'
A__     :      Optional[Any]             =			'none'






def   a      (						lowerCamelCase_		,       lowerCamelCase_    ):






				'''simple docstring'''
				lowercase__       			=      value.split(lowerCamelCase_    )
				return len(lowerCamelCase_    ) > 1 and any((len(lowerCamelCase_    ) == 3 for x in split)    )






def   a      (						lowerCamelCase_    ):






				'''simple docstring'''
				if isinstance(lowerCamelCase_		,       lowerCamelCase_    ):
								return value
				if isinstance(lowerCamelCase_		,       lowerCamelCase_    ):
								return float(lowerCamelCase_    )
				if not isinstance(lowerCamelCase_		,       lowerCamelCase_    ):
								raise ValueError('''Argument value is not a string. Can\'t parse it as float'''    )
				lowercase__       			=      value

				try:
								# Example: 1,000.7
								if "." in sanitized and "," in sanitized:
												return float(sanitized.replace(''','''		,       ''''''    )    )
								# 1,000
								if "," in sanitized and _split_thousands(''','''		,       lowerCamelCase_    ):
												return float(sanitized.replace(''','''		,       ''''''    )    )
								# 5,5556
								if "," in sanitized and sanitized.count(''','''    ) == 1 and not _split_thousands(''','''		,       lowerCamelCase_    ):
												return float(sanitized.replace(''','''		,       '''.'''    )    )
								# 0.0.0.1
								if sanitized.count('''.'''    ) > 1:
												return float(sanitized.replace('''.'''		,       ''''''    )    )
								# 0,0,0,1
								if sanitized.count(''','''    ) > 1:
												return float(sanitized.replace(''','''		,       ''''''    )    )
								return float(lowerCamelCase_    )
				except ValueError:
								# Avoid adding the sanitized value in the error message.
								raise ValueError('''Unable to convert value to float'''    )






def   a      (						lowerCamelCase_    ):






				'''simple docstring'''
				if answer is None:
								return None
				try:
								lowercase__       			=      convert_to_float(lowerCamelCase_    )
								if isinstance(lowerCamelCase_		,       lowerCamelCase_    ) and math.isnan(lowerCamelCase_    ):
												return None
								return value
				except ValueError:
								return answer.lower()


A__     :      Tuple             =			{
    'text': lambda x: x,
    'real': convert_to_float,
}
class 				_UpperCAmelCase (	enum.Enum     ):

				"""simple docstring"""




				lowercase__    							=	0
				lowercase__    							=	1
				lowercase__    							=	2
				lowercase__    							=	3
				lowercase__    							=	4
				lowercase__    							=	5



class 				_UpperCAmelCase (	enum.Enum     ):

				"""simple docstring"""




				lowercase__    							=	0
				lowercase__    							=	1
				lowercase__    							=	2



@dataclasses.dataclass
class 				_UpperCAmelCase :

				"""simple docstring"""




				lowercase__    							=	42
				lowercase__    							=	42
				lowercase__    							=	42



A__     :      str             =			re.compile(r'\w+|[^\w\s]+', re.UNICODE | re.MULTILINE | re.DOTALL)






def   a      (						lowerCamelCase_    ):






				'''simple docstring'''
				return list(_TOKENIZER.findall(x.lower()    )    )






def   a      (						lowerCamelCase_		,       lowerCamelCase_		,       lowerCamelCase_    ):






				'''simple docstring'''
				if operator == _Operator.EQUALS:
								return src == tgt
				elif operator == _Operator.GREATER:
								return src > tgt
				elif operator == _Operator.LESSER:
								return src < tgt
				raise ValueError(F"""Unknown operator: {operator}"""    )






def   a      (						lowerCamelCase_		,       lowerCamelCase_		,       lowerCamelCase_    ):






				'''simple docstring'''
				lowercase__       			=      table['''types''']
				return _TYPE_CONVERTER[types[column]](lowerCamelCase_    )






def   a      (						lowerCamelCase_    ):






				'''simple docstring'''
				return isinstance(lowerCamelCase_		,       lowerCamelCase_    )






def   a      (						lowerCamelCase_		,       lowerCamelCase_		,       lowerCamelCase_    ):






				'''simple docstring'''
				for cond in conditions:
								lowercase__       			=      row[cond.column]

								lowercase__       			=      _parse_value(lowerCamelCase_		,       cond.column		,       cond.cmp_value    )

								if _is_string(lowerCamelCase_    ) and _is_string(lowerCamelCase_    ):
												lowercase__       			=      _normalize_for_match(lowerCamelCase_    )
												lowercase__       			=      _normalize_for_match(lowerCamelCase_    )

								if not isinstance(lowerCamelCase_		,       type(lowerCamelCase_    )    ):
												raise ValueError('''Type difference {} != {}'''.format(type(lowerCamelCase_    )		,       type(lowerCamelCase_    )    )    )

								if not _compare(cond.operator		,       lowerCamelCase_		,       lowerCamelCase_    ):
												return False
				return True






def   a      (						lowerCamelCase_		,       lowerCamelCase_		,       lowerCamelCase_    ):






				'''simple docstring'''
				if not answer_coordinates:
								if aggregation_op == _Aggregation.COUNT:
												return 0.0
								else:
												return EMPTY_ANSWER_AGG

    # Count can support non numeric answers.
				if aggregation_op == _Aggregation.COUNT:
								return float(len(lowerCamelCase_    )    )

				# If we have just one answer, if float returns it or try a conversion.
				lowercase__       			=      [table['''rows'''][i][j] for (i, j) in answer_coordinates]
				if len(lowerCamelCase_    ) == 1:
								try:
												return convert_to_float(values[0]    )
								except ValueError as e:
												if aggregation_op != _Aggregation.NONE:
																raise e

				if aggregation_op == _Aggregation.NONE:
								return None

				# Other aggregation only support numeric values. Bail out if we have strings.
				if not all((isinstance(lowerCamelCase_		,       (int, float)    ) for v in values)    ):
								return None

				if aggregation_op == _Aggregation.SUM:
								return float(sum(lowerCamelCase_    )    )
				elif aggregation_op == _Aggregation.AVERAGE:
								return sum(lowerCamelCase_    ) / len(lowerCamelCase_    )
				else:
								raise ValueError(F"""Unknown aggregation: {aggregation_op}"""    )






def   a      (						lowerCamelCase_		,       lowerCamelCase_    ):






				'''simple docstring'''
				lowercase__       			=      sql_query['''agg''']
				if aggregation_op_index >= 3:
								lowercase__       			=      _Aggregation(lowerCamelCase_    )
				else:
								lowercase__       			=      _Aggregation.NONE

				lowercase__       			=      sql_query['''sel''']
				lowercase__       			=      [
				    _Condition(lowerCamelCase_		,       _Operator(lowerCamelCase_    )		,       lowerCamelCase_    )
				    for column, operator, cmp_value in zip(
				        sql_query['''conds''']['''column_index''']		,       sql_query['''conds''']['''operator_index''']		,       sql_query['''conds''']['''condition''']    )
				]

				lowercase__       			=      []
				for row in range(len(table['''rows''']    )    ):
								if _respect_conditions(lowerCamelCase_		,       table['''rows'''][row]		,       lowerCamelCase_    ):
												indices.append((row, target_column)    )

				if not indices:
								return [], aggregation_op

				if len(lowerCamelCase_    ) == 1:
								return indices, aggregation_op

				# Parsing of MIN/MAX.
				if aggregation_op_index in (1, 2):
								lowercase__       			=      {2: min, 1: max}
								lowercase__       			=      [(table['''rows'''][i][j], index) for index, (i, j) in enumerate(lowerCamelCase_    )]
								lowercase__       			=      functools.reduce(operators[sql_query['''agg''']]		,       lowerCamelCase_    )

								lowercase__       			=      [indices[reduced[1]]]
								return ret, _Aggregation.NONE

				return indices, aggregation_op






def   a      (						lowerCamelCase_		,       lowerCamelCase_		,       lowerCamelCase_    ):






				'''simple docstring'''
				if float_answer is not None:
								return [str(lowerCamelCase_    )]
				return [str(table['''real_rows'''][r][c]    ) for r, c in answer_coordinates]






def   a      (						lowerCamelCase_		,       lowerCamelCase_    ):






				'''simple docstring'''
				lowercase__			,						lowercase__       			=      _get_answer_coordinates(lowerCamelCase_		,       lowerCamelCase_    )
				lowercase__       			=      _get_float_answer(lowerCamelCase_		,       lowerCamelCase_		,       lowerCamelCase_    )
				lowercase__       			=      _get_answer_text(lowerCamelCase_		,       lowerCamelCase_		,       lowerCamelCase_    )
				# keep the original data the same with TaPas
				if len(lowerCamelCase_    ) == 0:
								lowercase__       			=      [EMPTY_ANSWER]
				return answer_text




