

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


__snake_case							:     Optional[Any] 						=	logging.getLogger(__name__)



@dataclass
class    A__:
						"""simple docstring"""






						_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							(		):

			'''simple docstring'''



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

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

			a_		:		int				    =				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       ,					)
			a_		:		Union[str, 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=__A       ,					)
			a_		:		List[str]				    =				AutoModelForQuestionAnswering.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
			a_		:		Dict				    =				hasattr(model.config       ,					"""lang2id""")
			a_		:		Dict				    =				(
			    SquadDataset(
			        __A       ,					tokenizer=__A       ,					is_language_sensitive=__A       ,					cache_dir=model_args.cache_dir)
			    if training_args.do_train
			    else None
			)
			a_		:		Optional[int]				    =				(
			    SquadDataset(
			        __A       ,					tokenizer=__A       ,					mode="""dev"""       ,					is_language_sensitive=__A       ,					cache_dir=model_args.cache_dir       ,					)
			    if training_args.do_eval
			    else None
			)

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

			# Initialize our Trainer
			a_		:		str				    =				Trainer(
			    model=__A       ,					args=__A       ,					train_dataset=__A       ,					eval_dataset=__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)


def 			_UpperCAmelCase							(		a__):

			'''simple docstring'''



			main()


if __name__ == "__main__":
	main()









def 			_UpperCAmelCase							(		a__):

			'''simple docstring'''



			return 1 if input_a == 0 else 0


def 			_UpperCAmelCase							(		):

			'''simple docstring'''



			assert not_gate(0) == 1
			assert not_gate(1) == 0


if __name__ == "__main__":
	print(not_gate(0))
	print(not_gate(1))


