


import argparse
import logging
import os
from pathlib import Path
from typing import Any, Dict

import pytorch_lightning as pl
from pytorch_lightning.utilities import rank_zero_info

from transformers import (
    AdamW,
    AutoConfig,
    AutoModel,
    AutoModelForPreTraining,
    AutoModelForQuestionAnswering,
    AutoModelForSeqaSeqLM,
    AutoModelForSequenceClassification,
    AutoModelForTokenClassification,
    AutoModelWithLMHead,
    AutoTokenizer,
    PretrainedConfig,
    PreTrainedTokenizer,
)
from transformers.optimization import (
    Adafactor,
    get_cosine_schedule_with_warmup,
    get_cosine_with_hard_restarts_schedule_with_warmup,
    get_linear_schedule_with_warmup,
    get_polynomial_decay_schedule_with_warmup,
)
from transformers.utils.versions import require_version


UpperCAmelCase__     			=							logging.getLogger(__name__)

require_version('''pytorch_lightning>=1.0.4''')

UpperCAmelCase__     			=							{
    """base""": AutoModel,
    """sequence-classification""": AutoModelForSequenceClassification,
    """question-answering""": AutoModelForQuestionAnswering,
    """pretraining""": AutoModelForPreTraining,
    """token-classification""": AutoModelForTokenClassification,
    """language-modeling""": AutoModelWithLMHead,
    """summarization""": AutoModelForSeqaSeqLM,
    """translation""": AutoModelForSeqaSeqLM,
}


# update this and the import above to support new schedulers from transformers.optimization
UpperCAmelCase__     			=							{
    """linear""": get_linear_schedule_with_warmup,
    """cosine""": get_cosine_schedule_with_warmup,
    """cosine_w_restarts""": get_cosine_with_hard_restarts_schedule_with_warmup,
    """polynomial""": get_polynomial_decay_schedule_with_warmup,
    # '': get_constant_schedule,             # not supported for now
    # '': get_constant_schedule_with_warmup, # not supported for now
}
UpperCAmelCase__     			=							sorted(arg_to_scheduler.keys())
UpperCAmelCase__     			=							"""{""" + """, """.join(arg_to_scheduler_choices) + """}"""







class    lowerCamelCase__     ( pl.LightningModule):





     def __init__(self	,  UpperCAmelCase	,  UpperCAmelCase=None	,  UpperCAmelCase="base"	,  UpperCAmelCase=None	,  UpperCAmelCase=None	,  UpperCAmelCase=None	,  **UpperCAmelCase	,  )  ->     Union[str, Any]:
          super().__init__()
          # TODO: move to self.save_hyperparameters()
          # self.save_hyperparameters()
          # can also expand arguments into trainer signature for easier reading

          self.save_hyperparameters(UpperCAmelCase )
          _lowercase							   =0
          _lowercase							   =Path(self.hparams.output_dir )
          _lowercase							   =self.hparams.cache_dir if self.hparams.cache_dir else None
          if config is None:
               _lowercase							   =AutoConfig.from_pretrained(
                   self.hparams.config_name if self.hparams.config_name else self.hparams.model_name_or_path	,  **({'''num_labels''': num_labels} if num_labels is not None else {})	,  cache_dir=UpperCAmelCase	,  **UpperCAmelCase	,  )
          else:
               _lowercase							   =config

          _lowercase							   =('encoder_layerdrop', 'decoder_layerdrop', 'dropout', 'attention_dropout')
          for p in extra_model_params:
               if getattr(self.hparams	,  UpperCAmelCase	,  UpperCAmelCase ):
                    assert hasattr(self.config	,  UpperCAmelCase ), f"model config doesn't have a `{p}` attribute"
                    setattr(self.config	,  UpperCAmelCase	,  getattr(self.hparams	,  UpperCAmelCase ) )

          if tokenizer is None:
               _lowercase							   =AutoTokenizer.from_pretrained(
                   self.hparams.tokenizer_name if self.hparams.tokenizer_name else self.hparams.model_name_or_path	,  cache_dir=UpperCAmelCase	,  )
          else:
               _lowercase							   =tokenizer
          _lowercase							   =MODEL_MODES[mode]
          if model is None:
               _lowercase							   =self.model_type.from_pretrained(
                   self.hparams.model_name_or_path	,  from_tf=bool('''.ckpt''' in self.hparams.model_name_or_path )	,  config=self.config	,  cache_dir=UpperCAmelCase	,  )
          else:
               _lowercase							   =model





     def   __A      (self	,  *UpperCAmelCase	,  **UpperCAmelCase )  ->     Any:
          _lowercase							   =self.model_type.from_pretrained(*UpperCAmelCase	,  **UpperCAmelCase )





     def   __A      (self )  ->     str:
          _lowercase							   =arg_to_scheduler[self.hparams.lr_scheduler]
          _lowercase							   =get_schedule_func(
              self.opt	,  num_warmup_steps=self.hparams.warmup_steps	,  num_training_steps=self.total_steps() )
          _lowercase							   ={'scheduler': scheduler, 'interval': 'step', 'frequency': 1}
          return scheduler





     def   __A      (self )  ->     Any:
          _lowercase							   =self.model
          _lowercase							   =['bias', 'LayerNorm.weight']
          _lowercase							   =[
              {
                  'params': [p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay )],
                  'weight_decay': self.hparams.weight_decay,
              },
              {
                  'params': [p for n, p in model.named_parameters() if any(nd in n for nd in no_decay )],
                  'weight_decay': 0.0,
              },
          ]
          if self.hparams.adafactor:
               _lowercase							   =Adafactor(
                   UpperCAmelCase	,  lr=self.hparams.learning_rate	,  scale_parameter=UpperCAmelCase	,  relative_step=UpperCAmelCase )

          else:
               _lowercase							   =AdamW(
                   UpperCAmelCase	,  lr=self.hparams.learning_rate	,  eps=self.hparams.adam_epsilon )
          _lowercase							   =optimizer

          _lowercase							   =self.get_lr_scheduler()

          return [optimizer], [scheduler]





     def   __A      (self	,  UpperCAmelCase	,  UpperCAmelCase )  ->     Optional[int]:
          return self.validation_step(UpperCAmelCase	,  UpperCAmelCase )





     def   __A      (self	,  UpperCAmelCase )  ->     str:
          return self.validation_end(UpperCAmelCase )





     def   __A      (self )  ->     Union[str, Any]:
          _lowercase							   =max(1	,  self.hparams.gpus )  # TODO: consider num_tpu_cores
          _lowercase							   =self.hparams.train_batch_size * self.hparams.accumulate_grad_batches * num_devices
          return (self.dataset_size / effective_batch_size) * self.hparams.max_epochs





     def   __A      (self	,  UpperCAmelCase )  ->     Optional[int]:
          if stage == "test":
               _lowercase							   =len(self.test_dataloader().dataset )
          else:
               _lowercase							   =self.get_dataloader('''train'''	,  self.hparams.train_batch_size	,  shuffle=UpperCAmelCase )
               _lowercase							   =len(self.train_dataloader().dataset )





     def   __A      (self	,  UpperCAmelCase	,  UpperCAmelCase	,  UpperCAmelCase = False )  ->     str:
          raise NotImplementedError('''You must implement this for your task''' )





     def   __A      (self )  ->     Optional[Any]:
          return self.train_loader





     def   __A      (self )  ->     Optional[int]:
          return self.get_dataloader('''dev'''	,  self.hparams.eval_batch_size	,  shuffle=UpperCAmelCase )





     def   __A      (self )  ->     str:
          return self.get_dataloader('''test'''	,  self.hparams.eval_batch_size	,  shuffle=UpperCAmelCase )





     def   __A      (self	,  UpperCAmelCase )  ->     int:
          return os.path.join(
              self.hparams.data_dir	,  '''cached_{}_{}_{}'''.format(
                  UpperCAmelCase	,  list(filter(UpperCAmelCase	,  self.hparams.model_name_or_path.split('''/''' ) ) ).pop()	,  str(self.hparams.max_seq_length )	,  )	,  )





     @pl.utilities.rank_zero_only
     def   __A      (self	,  UpperCAmelCase )  ->     List[str]:
          _lowercase							   =self.output_dir.joinpath('''best_tfmr''' )
          _lowercase							   =self.step_count
          self.model.save_pretrained(UpperCAmelCase )
          self.tokenizer.save_pretrained(UpperCAmelCase )





     @staticmethod
     def   __A      (UpperCAmelCase	,  UpperCAmelCase )  ->     int:
          parser.add_argument(
              '''--model_name_or_path'''	,  default=UpperCAmelCase	,  type=UpperCAmelCase	,  required=UpperCAmelCase	,  help='''Path to pretrained model or model identifier from huggingface.co/models'''	,  )
          parser.add_argument(
              '''--config_name'''	,  default=''''''	,  type=UpperCAmelCase	,  help='''Pretrained config name or path if not the same as model_name''' )
          parser.add_argument(
              '''--tokenizer_name'''	,  default=UpperCAmelCase	,  type=UpperCAmelCase	,  help='''Pretrained tokenizer name or path if not the same as model_name'''	,  )
          parser.add_argument(
              '''--cache_dir'''	,  default=''''''	,  type=UpperCAmelCase	,  help='''Where do you want to store the pre-trained models downloaded from huggingface.co'''	,  )
          parser.add_argument(
              '''--encoder_layerdrop'''	,  type=UpperCAmelCase	,  help='''Encoder layer dropout probability (Optional). Goes into model.config'''	,  )
          parser.add_argument(
              '''--decoder_layerdrop'''	,  type=UpperCAmelCase	,  help='''Decoder layer dropout probability (Optional). Goes into model.config'''	,  )
          parser.add_argument(
              '''--dropout'''	,  type=UpperCAmelCase	,  help='''Dropout probability (Optional). Goes into model.config'''	,  )
          parser.add_argument(
              '''--attention_dropout'''	,  type=UpperCAmelCase	,  help='''Attention dropout probability (Optional). Goes into model.config'''	,  )
          parser.add_argument('''--learning_rate'''	,  default=5e-5	,  type=UpperCAmelCase	,  help='''The initial learning rate for Adam.''' )
          parser.add_argument(
              '''--lr_scheduler'''	,  default='''linear'''	,  choices=UpperCAmelCase	,  metavar=UpperCAmelCase	,  type=UpperCAmelCase	,  help='''Learning rate scheduler'''	,  )
          parser.add_argument('''--weight_decay'''	,  default=0.0	,  type=UpperCAmelCase	,  help='''Weight decay if we apply some.''' )
          parser.add_argument('''--adam_epsilon'''	,  default=1e-8	,  type=UpperCAmelCase	,  help='''Epsilon for Adam optimizer.''' )
          parser.add_argument('''--warmup_steps'''	,  default=0	,  type=UpperCAmelCase	,  help='''Linear warmup over warmup_steps.''' )
          parser.add_argument('''--num_workers'''	,  default=4	,  type=UpperCAmelCase	,  help='''kwarg passed to DataLoader''' )
          parser.add_argument('''--num_train_epochs'''	,  dest='''max_epochs'''	,  default=3	,  type=UpperCAmelCase )
          parser.add_argument('''--train_batch_size'''	,  default=3_2	,  type=UpperCAmelCase )
          parser.add_argument('''--eval_batch_size'''	,  default=3_2	,  type=UpperCAmelCase )
          parser.add_argument('''--adafactor'''	,  action='''store_true''' )







class    lowerCamelCase__     ( pl.Callback):





     def   __A      (self	,  UpperCAmelCase	,  UpperCAmelCase )  ->     Optional[Any]:
          if (
              trainer.is_global_zero and trainer.global_rank == 0
          ):  # we initialize the retriever only on master worker with RAY. In new pytorch-lightning accelorators are removed.
               pl_module.model.rag.retriever.init_retrieval()  # better to use hook functions.







class    lowerCamelCase__     ( pl.Callback):





     def   __A      (self	,  UpperCAmelCase	,  UpperCAmelCase )  ->     str:
          _lowercase							   =trainer.lr_schedulers[0]['scheduler']
          _lowercase							   ={f"lr_group_{i}": lr for i, lr in enumerate(lr_scheduler.get_lr() )}
          pl_module.logger.log_metrics(UpperCAmelCase )





     def   __A      (self	,  UpperCAmelCase	,  UpperCAmelCase )  ->     Any:
          rank_zero_info('''***** Validation results *****''' )
          _lowercase							   =trainer.callback_metrics
          # Log results
          for key in sorted(UpperCAmelCase ):
               if key not in ["log", "progress_bar"]:
                    rank_zero_info('''{} = {}\n'''.format(UpperCAmelCase	,  str(metrics[key] ) ) )





     def   __A      (self	,  UpperCAmelCase	,  UpperCAmelCase )  ->     str:
          rank_zero_info('''***** Test results *****''' )
          _lowercase							   =trainer.callback_metrics
          # Log and save results to file
          _lowercase							   =os.path.join(pl_module.hparams.output_dir	,  '''test_results.txt''' )
          with open(UpperCAmelCase	,  '''w''' ) as writer:
               for key in sorted(UpperCAmelCase ):
                    if key not in ["log", "progress_bar"]:
                         rank_zero_info('''{} = {}\n'''.format(UpperCAmelCase	,  str(metrics[key] ) ) )
                         writer.write('''{} = {}\n'''.format(UpperCAmelCase	,  str(metrics[key] ) ) )



def        UpperCAmelCase_      (							__snake_case  ,		__snake_case		)  ->    str:







     """simple docstring"""


     parser.add_argument(
         '''--output_dir'''  ,		default=lowerCAmelCase__  ,		type=lowerCAmelCase__  ,		required=lowerCAmelCase__  ,		help='''The output directory where the model predictions and checkpoints will be written.'''  ,		)
     parser.add_argument(
         '''--fp16'''  ,		action='''store_true'''  ,		help='''Whether to use 16-bit (mixed) precision (through NVIDIA apex) instead of 32-bit'''  ,		)

     parser.add_argument(
         '''--fp16_opt_level'''  ,		type=lowerCAmelCase__  ,		default='''O2'''  ,		help=(
             '''For fp16: Apex AMP optimization level selected in [\'O0\', \'O1\', \'O2\', and \'O3\'].'''
             '''See details at https://nvidia.github.io/apex/amp.html'''
         )  ,		)
     parser.add_argument('''--n_tpu_cores'''  ,		dest='''tpu_cores'''  ,		type=lowerCAmelCase__		)
     parser.add_argument('''--max_grad_norm'''  ,		dest='''gradient_clip_val'''  ,		default=1.0  ,		type=lowerCAmelCase__  ,		help='''Max gradient norm'''		)
     parser.add_argument('''--do_train'''  ,		action='''store_true'''  ,		help='''Whether to run training.'''		)
     parser.add_argument('''--do_predict'''  ,		action='''store_true'''  ,		help='''Whether to run predictions on the test set.'''		)
     parser.add_argument(
         '''--gradient_accumulation_steps'''  ,		dest='''accumulate_grad_batches'''  ,		type=lowerCAmelCase__  ,		default=1  ,		help='''Number of updates steps to accumulate before performing a backward/update pass.'''  ,		)
     parser.add_argument('''--seed'''  ,		type=lowerCAmelCase__  ,		default=42  ,		help='''random seed for initialization'''		)
     parser.add_argument(
         '''--data_dir'''  ,		default=lowerCAmelCase__  ,		type=lowerCAmelCase__  ,		required=lowerCAmelCase__  ,		help='''The input data dir. Should contain the training files for the CoNLL-2003 NER task.'''  ,		)



def        UpperCAmelCase_      (							__snake_case  ,		__snake_case  ,		__snake_case=None  ,		__snake_case=True  ,		__snake_case=None  ,		__snake_case=[]  ,		__snake_case=None  ,		__snake_case=None  ,		**__snake_case  ,		)  ->    Optional[int]:







     """simple docstring"""


     pl.seed_everything(args.seed		)

     # init model
     _lowercase							   =Path(model.hparams.output_dir		)
     odir.mkdir(exist_ok=lowerCAmelCase__		)

     # add custom checkpoints
     if checkpoint_callback is None:
          _lowercase							   =pl.callbacks.ModelCheckpoint(
              filepath=args.output_dir  ,		prefix='''checkpoint'''  ,		monitor='''val_loss'''  ,		mode='''min'''  ,		save_top_k=1		)
     if early_stopping_callback:
          extra_callbacks.append(lowerCAmelCase__		)
     if logging_callback is None:
          _lowercase							   =LoggingCallback()

     _lowercase							   ={}

     # TODO: remove with PyTorch 1.6 since pl uses native amp
     if args.fpaa:
          _lowercase							   =16
          # train_params["amp_level"] = args.fp16_opt_level

     if args.gpus > 1:
          _lowercase							   ='auto'  # "ddp"
          _lowercase							   ='ddp'

     _lowercase							   =args.accumulate_grad_batches
     _lowercase							   =None  # extra_train_kwargs.get("profiler", None) #get unwanted logs
     _lowercase							   ='auto'

     _lowercase							   =pl.Trainer.from_argparse_args(
         lowerCAmelCase__  ,		weights_summary=lowerCAmelCase__  ,		callbacks=[logging_callback] + extra_callbacks + [checkpoint_callback] + [InitCallback()]  ,		logger=lowerCAmelCase__  ,		**lowerCAmelCase__  ,		)

     if args.do_train:
          trainer.fit(lowerCAmelCase__		)

     return trainer





import requests

try:
  from django.contrib.auth import authenticate, login
  from django.shortcuts import redirect, render
except ImportError:
  UpperCAmelCase__     			=							UpperCAmelCase__     			=							UpperCAmelCase__     			=							UpperCAmelCase__     			=							print
def        UpperCAmelCase_      (							__snake_case		)  ->    List[str]:







 """simple docstring"""


 _lowercase							   ='''secretKey'''
 _lowercase							   ='''https://www.google.com/recaptcha/api/siteverify'''

 # when method is not POST, direct user to login page
 if request.method != "POST":
  return render(__snake_case  ,		'''login.html'''		)

 # from the frontend, get username, password, and client_key
 _lowercase							   =request.POST.get('''username'''		)
 _lowercase							   =request.POST.get('''password'''		)
 _lowercase							   =request.POST.get('''g-recaptcha-response'''		)

 # post recaptcha response to Google's recaptcha api
 _lowercase							   =requests.post(__snake_case  ,		data={'''secret''': secret_key, '''response''': client_key}		)
 # if the recaptcha api verified our keys
 if response.json().get('''success'''  ,		__snake_case		):
  # authenticate the user
  _lowercase							   =authenticate(__snake_case  ,		username=__snake_case  ,		password=__snake_case		)
  if user_in_database:
   login(__snake_case  ,		__snake_case		)
   return redirect('''/your-webpage'''		)
 return render(__snake_case  ,		'''login.html'''		)

