



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


a_							=      logging.getLogger(__name__)




def       __lowerCAmelCase      (						A_   : str						,	A_   : int					)    ->  List[Any]:
  return (preds == labels).mean()


@dataclass
class 			UpperCAmelCase__    :



  """simple docstring"""






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






@dataclass
class 			UpperCAmelCase__    :



  """simple docstring"""






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






def       __lowerCAmelCase      (						)    ->  List[Any]:
  __UpperCAmelCase						    =       HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)					)
  __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"						,	A_					)

  # Set seed
  set_seed(training_args.seed					)

  try:
    __UpperCAmelCase						    =       processors[data_args.task_name]()
    __UpperCAmelCase						    =       processor.get_labels()
    __UpperCAmelCase						    =       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.

  __UpperCAmelCase						    =       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						,	)
  __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						,	)
  __UpperCAmelCase						    =       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
  __UpperCAmelCase						    =       (
      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
  )
  __UpperCAmelCase						    =       (
      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_   : int					) -> Dict:
    __UpperCAmelCase						    =       np.argmax(p.predictions						,	axis=1					)
    return {"acc": simple_accuracy(A_						,	p.label_ids					)}

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

  # Initialize our Trainer
  __UpperCAmelCase						    =       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
  __UpperCAmelCase						    =       {}
  if training_args.do_eval:
    logger.info("*** Evaluate ***"					)

    __UpperCAmelCase						    =       trainer.evaluate()

    __UpperCAmelCase						    =       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_   : List[str]					)    ->  Any:
  main()


if __name__ == "__main__":
       main()




from datetime import datetime

import requests




def       __lowerCAmelCase      (						A_   : str					)    ->  bytes:
  __UpperCAmelCase						    =       "https://downloadgram.net/wp-json/wppress/video-downloader/video?url="
  __UpperCAmelCase						    =       requests.get(base_url + url					).json()[0]["urls"][0]["src"]
  return requests.get(A_					).content


if __name__ == "__main__":
       a_							=      input("""Enter Video/IGTV url: """).strip()
       a_							=      F"{datetime.now():%Y-%m-%d_%H:%M:%S}.mp4"
       with open(file_name, """wb""") as fp:
              fp.write(download_video(url))
       print(F"Done. Video saved to disk as {file_name}.")



