

'''simple docstring'''
import os
from shutil import copyfile
from typing import Optional, Tuple

from ...file_utils import is_sentencepiece_available
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging


if is_sentencepiece_available():
     from .tokenization_deberta_va import DebertaVaTokenizer
else:
     lowerCamelCase				:   List[str]      				=  None

lowerCamelCase				:   Union[str, Any]      				=  logging.get_logger(__name__)

lowerCamelCase				:   str      				=  {"vocab_file": "spm.model", "tokenizer_file": "tokenizer.json"}

lowerCamelCase				:   str      				=  {
    "vocab_file": {
        "microsoft/deberta-v2-xlarge": "https://huggingface.co/microsoft/deberta-v2-xlarge/resolve/main/spm.model",
        "microsoft/deberta-v2-xxlarge": "https://huggingface.co/microsoft/deberta-v2-xxlarge/resolve/main/spm.model",
        "microsoft/deberta-v2-xlarge-mnli": (
            "https://huggingface.co/microsoft/deberta-v2-xlarge-mnli/resolve/main/spm.model"
        ),
        "microsoft/deberta-v2-xxlarge-mnli": (
            "https://huggingface.co/microsoft/deberta-v2-xxlarge-mnli/resolve/main/spm.model"
        ),
    }
}

lowerCamelCase				:   List[str]      				=  {
    "microsoft/deberta-v2-xlarge": 5_1_2,
    "microsoft/deberta-v2-xxlarge": 5_1_2,
    "microsoft/deberta-v2-xlarge-mnli": 5_1_2,
    "microsoft/deberta-v2-xxlarge-mnli": 5_1_2,
}

lowerCamelCase				:   Any      				=  {
    "microsoft/deberta-v2-xlarge": {"do_lower_case": False},
    "microsoft/deberta-v2-xxlarge": {"do_lower_case": False},
    "microsoft/deberta-v2-xlarge-mnli": {"do_lower_case": False},
    "microsoft/deberta-v2-xxlarge-mnli": {"do_lower_case": False},
}







class 							A__					( A__						):
  A__					=       VOCAB_FILES_NAMES
  A__					=       PRETRAINED_VOCAB_FILES_MAP
  A__					=       PRETRAINED_INIT_CONFIGURATION
  A__					=       PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  A__					=       DebertaVaTokenizer





  def __init__(	self   :			int							,      _a   :			Dict=None							,      _a   :			Union[str, Any]=None							,      _a   :			Dict=False							,      _a   :			Optional[int]=False							,      _a   :			Dict="[CLS]"							,      _a   :			Dict="[SEP]"							,      _a   :			Optional[int]="[UNK]"							,      _a   :			List[str]="[SEP]"							,      _a   :			Union[str, Any]="[PAD]"							,      _a   :			Tuple="[CLS]"							,      _a   :			List[Any]="[MASK]"							,      **_a   :			Union[str, Any]							,      )			->					None:





       '''simple docstring'''






       super().__init__(
           _a							,      tokenizer_file=_a							,      do_lower_case=_a							,      bos_token=_a							,      eos_token=_a							,      unk_token=_a							,      sep_token=_a							,      pad_token=_a							,      cls_token=_a							,      mask_token=_a							,      split_by_punct=_a							,      **_a							,      )

       _SCREAMING_SNAKE_CASE												=do_lower_case
       _SCREAMING_SNAKE_CASE												=split_by_punct
       _SCREAMING_SNAKE_CASE												=vocab_file
       _SCREAMING_SNAKE_CASE												=False if not self.vocab_file else True





  def 		A						(	self   :			Tuple							,      _a   :			List[Any]							,      _a   :			List[str]=None				)			->					int:





       '''simple docstring'''






       if token_ids_a is None:
            return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
       _SCREAMING_SNAKE_CASE												=[self.cls_token_id]
       _SCREAMING_SNAKE_CASE												=[self.sep_token_id]
       return cls + token_ids_a + sep + token_ids_a + sep





  def 		A						(	self   :			List[Any]							,      _a   :			Tuple							,      _a   :			Optional[int]=None							,      _a   :			Tuple=False				)			->					Dict:





       '''simple docstring'''






       if already_has_special_tokens:
            return super().get_special_tokens_mask(
                token_ids_a=_a							,      token_ids_a=_a							,      already_has_special_tokens=_a				)

       if token_ids_a is not None:
            return [1] + ([0] * len(_a				)) + [1] + ([0] * len(_a				)) + [1]
       return [1] + ([0] * len(_a				)) + [1]





  def 		A						(	self   :			Dict							,      _a   :			Dict							,      _a   :			Optional[int]=None				)			->					Any:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE												=[self.sep_token_id]
       _SCREAMING_SNAKE_CASE												=[self.cls_token_id]
       if token_ids_a is None:
            return len(cls + token_ids_a + sep				) * [0]
       return len(cls + token_ids_a + sep				) * [0] + len(token_ids_a + sep				) * [1]





  def 		A						(	self   :			List[str]							,      _a   :			str							,      _a   :			Optional[str] = None				)			->					Tuple[str]:





       '''simple docstring'''






       if not self.can_save_slow_tokenizer:
            raise ValueError(
                'Your fast tokenizer does not have the necessary information to save the vocabulary for a slow '
                'tokenizer.'				)

       if not os.path.isdir(_a				):
            logger.error(f"Vocabulary path ({save_directory}) should be a directory"				)
            return
       _SCREAMING_SNAKE_CASE												=os.path.join(
           _a							,      (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']				)

       if os.path.abspath(self.vocab_file				) != os.path.abspath(_a				):
            copyfile(self.vocab_file							,      _a				)

       return (out_vocab_file,)





'''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				:   int      				=  logging.getLogger(__name__)







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


def  _lowerCAmelCase      (		)   ->    Union[str, Any]:
     """simple docstring"""




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

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

     _SCREAMING_SNAKE_CASE												=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							,				)
     _SCREAMING_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							,				use_fast=_UpperCamelCase							,				)
     _SCREAMING_SNAKE_CASE												=AutoModelForQuestionAnswering.from_pretrained(
         model_args.model_name_or_path							,				from_tf=bool('.ckpt' in model_args.model_name_or_path       )							,				config=_UpperCamelCase							,				cache_dir=model_args.cache_dir							,				)

     # Get datasets
     _SCREAMING_SNAKE_CASE												=hasattr(model.config							,				'lang2id'       )
     _SCREAMING_SNAKE_CASE												=(
         SquadDataset(
             _UpperCamelCase							,				tokenizer=_UpperCamelCase							,				is_language_sensitive=_UpperCamelCase							,				cache_dir=model_args.cache_dir       )
         if training_args.do_train
         else None
     )
     _SCREAMING_SNAKE_CASE												=(
         SquadDataset(
             _UpperCamelCase							,				tokenizer=_UpperCamelCase							,				mode='dev'							,				is_language_sensitive=_UpperCamelCase							,				cache_dir=model_args.cache_dir							,				)
         if training_args.do_eval
         else None
     )

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

     # Initialize our Trainer
     _SCREAMING_SNAKE_CASE												=Trainer(
         model=_UpperCamelCase							,				args=_UpperCamelCase							,				train_dataset=_UpperCamelCase							,				eval_dataset=_UpperCamelCase							,				data_collator=_UpperCamelCase							,				)

     # 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  _lowerCAmelCase      (		_UpperCamelCase		:  Tuple       )   ->    List[str]:
     """simple docstring"""




     main()


if __name__ == "__main__":
     main()
