




import subprocess
from argparse import ArgumentParser
from typing import List, Union

from huggingface_hub.hf_api import HfFolder, create_repo, whoami
from requests.exceptions import HTTPError

from . import BaseTransformersCLICommand
class 				__a (			__lowerCamelCase					):


     """simple docstring"""


     @staticmethod
     def   __A    (     _UpperCamelCase      :			ArgumentParser						)		->       str:


         '''simple docstring'''





         SCREAMING_SNAKE_CASE__       =parser.add_parser("""login"""    ,help="""Log in using the same credentials as on huggingface.co"""						)
         login_parser.set_defaults(func=lambda _UpperCamelCase						: LoginCommand(_UpperCamelCase						)						)
         SCREAMING_SNAKE_CASE__       =parser.add_parser("""whoami"""    ,help="""Find out which huggingface.co account you are logged in as."""						)
         whoami_parser.set_defaults(func=lambda _UpperCamelCase						: WhoamiCommand(_UpperCamelCase						)						)
         SCREAMING_SNAKE_CASE__       =parser.add_parser("""logout"""    ,help="""Log out"""						)
         logout_parser.set_defaults(func=lambda _UpperCamelCase						: LogoutCommand(_UpperCamelCase						)						)

         # new system: git-based repo system
         SCREAMING_SNAKE_CASE__       =parser.add_parser(
             """repo"""    ,help="""Deprecated: use `huggingface-cli` instead. Commands to interact with your huggingface.co repos."""    ,)
         SCREAMING_SNAKE_CASE__       =repo_parser.add_subparsers(
             help="""Deprecated: use `huggingface-cli` instead. huggingface.co repos related commands"""						)
         SCREAMING_SNAKE_CASE__       =repo_subparsers.add_parser(
             """create"""    ,help="""Deprecated: use `huggingface-cli` instead. Create a new repo on huggingface.co"""						)
         repo_create_parser.add_argument(
             """name"""    ,type=_UpperCamelCase    ,help="""Name for your model's repo. Will be namespaced under your username to build the model id."""    ,)
         repo_create_parser.add_argument("""--organization"""    ,type=_UpperCamelCase    ,help="""Optional: organization namespace."""						)
         repo_create_parser.add_argument("""-y"""    ,"""--yes"""    ,action="""store_true"""    ,help="""Optional: answer Yes to the prompt"""						)
         repo_create_parser.set_defaults(func=lambda _UpperCamelCase						: RepoCreateCommand(_UpperCamelCase						)						)






class 				__a :


     """simple docstring"""


     _A    :   int     =  "\u001b[1m"
     _A    :   Optional[int]     =  "\u001b[31m"
     _A    :   List[Any]     =  "\u001b[90m"
     _A    :   int     =  "\u001b[0m"




     @classmethod
     def   __A    (     cls      :			Tuple    ,_UpperCamelCase      :			str						)		->       Optional[int]:


         '''simple docstring'''





         return f"""{cls._bold}{s}{cls._reset}"""




     @classmethod
     def   __A    (     cls      :			int    ,_UpperCamelCase      :			Union[str, Any]						)		->       Optional[Any]:


         '''simple docstring'''





         return f"""{cls._bold}{cls._red}{s}{cls._reset}"""




     @classmethod
     def   __A    (     cls      :			Optional[int]    ,_UpperCamelCase      :			List[Any]						)		->       List[str]:


         '''simple docstring'''





         return f"""{cls._gray}{s}{cls._reset}"""






def      UpperCAmelCase_   (     __UpperCamelCase,    __UpperCamelCase     ):
    SCREAMING_SNAKE_CASE__       =[max(len(str(__UpperCamelCase     )     ) for x in col     ) for col in zip(*__UpperCamelCase,    __UpperCamelCase     )]
    SCREAMING_SNAKE_CASE__       =("""{{:{}}} """ * len(__UpperCamelCase     )).format(*__UpperCamelCase     )
    SCREAMING_SNAKE_CASE__       =[]
    lines.append(row_format.format(*__UpperCamelCase     )     )
    lines.append(row_format.format(*["""-""" * w for w in col_widths]     )     )
    for row in rows:
        lines.append(row_format.format(*__UpperCamelCase     )     )
    return "\n".join(__UpperCamelCase     )
class 				__a :


     """simple docstring"""


     def __init__(     self      :			Union[str, Any]    ,_UpperCamelCase      :			Optional[int]						)		->       str:


         '''simple docstring'''





         SCREAMING_SNAKE_CASE__       =args






class 				__a (			__lowerCamelCase					):


     """simple docstring"""


     def   __A    (     self      :			Dict						)		->       Tuple:


         '''simple docstring'''





         print(
             ANSI.red(
                 """ERROR! `huggingface-cli login` uses an outdated login mechanism """
                 """that is not compatible with the Hugging Face Hub backend anymore. """
                 """Please use `huggingface-cli login instead."""						)						)






class 				__a (			__lowerCamelCase					):


     """simple docstring"""


     def   __A    (     self      :			Any						)		->       Tuple:


         '''simple docstring'''





         print(
             ANSI.red(
                 """WARNING! `transformers-cli whoami` is deprecated and will be removed in v5. Please use """
                 """`huggingface-cli whoami` instead."""						)						)
         SCREAMING_SNAKE_CASE__       =HfFolder.get_token()
         if token is None:
             print("""Not logged in"""						)
             exit()
         try:
             SCREAMING_SNAKE_CASE__      ,		SCREAMING_SNAKE_CASE__       =whoami(_UpperCamelCase						)
             print(_UpperCamelCase						)
             if orgs:
                 print(ANSI.bold("""orgs: """						)    ,""",""".join(_UpperCamelCase						)						)
         except HTTPError as e:
             print(_UpperCamelCase						)
             print(ANSI.red(e.response.text						)						)
             exit(1						)






class 				__a (			__lowerCamelCase					):


     """simple docstring"""


     def   __A    (     self      :			Any						)		->       Dict:


         '''simple docstring'''





         print(
             ANSI.red(
                 """ERROR! `transformers-cli logout` uses an outdated logout mechanism """
                 """that is not compatible with the Hugging Face Hub backend anymore. """
                 """Please use `huggingface-cli logout instead."""						)						)






class 				__a (			__lowerCamelCase					):


     """simple docstring"""


     def   __A    (     self      :			List[str]						)		->       int:


         '''simple docstring'''





         print(
             ANSI.red(
                 """WARNING! Managing repositories through transformers-cli is deprecated. """
                 """Please use `huggingface-cli` instead."""						)						)
         SCREAMING_SNAKE_CASE__       =HfFolder.get_token()
         if token is None:
             print("""Not logged in"""						)
             exit(1						)
         try:
             SCREAMING_SNAKE_CASE__       =subprocess.check_output(["""git""", """--version"""]						).decode("""utf-8"""						)
             print(ANSI.gray(stdout.strip()						)						)
         except FileNotFoundError:
             print("""Looks like you do not have git installed, please install."""						)

         try:
             SCREAMING_SNAKE_CASE__       =subprocess.check_output(["""git-lfs""", """--version"""]						).decode("""utf-8"""						)
             print(ANSI.gray(stdout.strip()						)						)
         except FileNotFoundError:
             print(
                 ANSI.red(
                     """Looks like you do not have git-lfs installed, please install."""
                     """ You can install from https://git-lfs.github.com/."""
                     """ Then run `git lfs install` (you only have to do this once)."""						)						)
         print(""""""						)

         SCREAMING_SNAKE_CASE__      ,		SCREAMING_SNAKE_CASE__       =whoami(_UpperCamelCase						)
         SCREAMING_SNAKE_CASE__       =self.args.organization if self.args.organization is not None else user
         SCREAMING_SNAKE_CASE__       =f"""{namespace}/{self.args.name}"""
         print(f"""You are about to create {ANSI.bold(_UpperCamelCase						)}"""						)

         if not self.args.yes:
             SCREAMING_SNAKE_CASE__       =input("""Proceed? [Y/n] """						).lower()
             if not (choice == "" or choice == "y" or choice == "yes"):
                 print("""Abort"""						)
                 exit()
         try:
             SCREAMING_SNAKE_CASE__       =create_repo(_UpperCamelCase    ,name=self.args.name    ,organization=self.args.organization						)
         except HTTPError as e:
             print(_UpperCamelCase						)
             print(ANSI.red(e.response.text						)						)
             exit(1						)
         print("""\nYour repo now lives at:"""						)
         print(f"""  {ANSI.bold(_UpperCamelCase						)}"""						)
         print("""\nYou can clone it locally with the command below, and commit/push as usual."""						)
         print(f"""\n  git clone {url}"""						)
         print(""""""						)












import logging
from pathlib import Path

import numpy as np
import pytorch_lightning as pl
import torch
from pytorch_lightning.callbacks import EarlyStopping, ModelCheckpoint
from pytorch_lightning.utilities import rank_zero_only

from utils import save_json



def      UpperCAmelCase_   (     __UpperCamelCase     ):
    SCREAMING_SNAKE_CASE__       =filter(lambda __UpperCamelCase     : p.requires_grad,    model.parameters()     )
    SCREAMING_SNAKE_CASE__       =sum([np.prod(p.size()     ) for p in model_parameters]     )
    return params


lowerCamelCase_  						=       logging.getLogger(__name__)
class 				__a (			pl.Callback					):


     """simple docstring"""


     def   __A    (     self      :			Optional[int]    ,_UpperCamelCase      :			Optional[Any]    ,_UpperCamelCase      :			Any						)		->       int:


         '''simple docstring'''





         SCREAMING_SNAKE_CASE__       ={f"""lr_group_{i}""": param["""lr"""] for i, param in enumerate(pl_module.trainer.optimizers[0].param_groups						)}
         pl_module.logger.log_metrics(_UpperCamelCase						)




     @rank_zero_only
     def   __A    (     self      :			Optional[int]    ,_UpperCamelCase      :			pl.Trainer    ,_UpperCamelCase      :			pl.LightningModule    ,_UpperCamelCase      :			str    ,_UpperCamelCase      :			Tuple=True						)		->       None:


         '''simple docstring'''





         logger.info(f"""***** {type_path} results at step {trainer.global_step:05d} *****"""						)
         SCREAMING_SNAKE_CASE__       =trainer.callback_metrics
         trainer.logger.log_metrics({k: v for k, v in metrics.items() if k not in ["""log""", """progress_bar""", """preds"""]}						)
         # Log results
         SCREAMING_SNAKE_CASE__       =Path(pl_module.hparams.output_dir						)
         if type_path == "test":
             SCREAMING_SNAKE_CASE__       =od / """test_results.txt"""
             SCREAMING_SNAKE_CASE__       =od / """test_generations.txt"""
         else:
             # this never gets hit. I prefer not to save intermediate generations, and results are in metrics.json
             # If people want this it will be easy enough to add back.
             SCREAMING_SNAKE_CASE__       =od / f"""{type_path}_results/{trainer.global_step:05d}.txt"""
             SCREAMING_SNAKE_CASE__       =od / f"""{type_path}_generations/{trainer.global_step:05d}.txt"""
             results_file.parent.mkdir(exist_ok=_UpperCamelCase						)
             generations_file.parent.mkdir(exist_ok=_UpperCamelCase						)
         with open(_UpperCamelCase    ,"""a+"""						) as writer:
             for key in sorted(_UpperCamelCase						):
                 if key in ["log", "progress_bar", "preds"]:
                     continue
                 SCREAMING_SNAKE_CASE__       =metrics[key]
                 if isinstance(_UpperCamelCase    ,torch.Tensor						):
                     SCREAMING_SNAKE_CASE__       =val.item()
                 SCREAMING_SNAKE_CASE__       =f"""{key}: {val:.6f}\n"""
                 writer.write(_UpperCamelCase						)

         if not save_generations:
             return

         if "preds" in metrics:
             SCREAMING_SNAKE_CASE__       ="""\n""".join(metrics["""preds"""]						)
             generations_file.open("""w+"""						).write(_UpperCamelCase						)




     @rank_zero_only
     def   __A    (     self      :			Tuple    ,_UpperCamelCase      :			int    ,_UpperCamelCase      :			Dict						)		->       Dict:


         '''simple docstring'''





         try:
             SCREAMING_SNAKE_CASE__       =pl_module.model.model.num_parameters()
         except AttributeError:
             SCREAMING_SNAKE_CASE__       =pl_module.model.num_parameters()

         SCREAMING_SNAKE_CASE__       =count_trainable_parameters(_UpperCamelCase						)
         # mp stands for million parameters
         trainer.logger.log_metrics({"""n_params""": npars, """mp""": npars / 1e6, """grad_mp""": n_trainable_pars / 1e6}						)




     @rank_zero_only
     def   __A    (     self      :			Optional[Any]    ,_UpperCamelCase      :			pl.Trainer    ,_UpperCamelCase      :			pl.LightningModule						)		->       Any:


         '''simple docstring'''





         save_json(pl_module.metrics    ,pl_module.metrics_save_path						)
         return self._write_logs(_UpperCamelCase    ,_UpperCamelCase    ,"""test"""						)




     @rank_zero_only
     def   __A    (     self      :			Optional[Any]    ,_UpperCamelCase      :			pl.Trainer    ,_UpperCamelCase      :			List[Any]						)		->       Dict:


         '''simple docstring'''





         save_json(pl_module.metrics    ,pl_module.metrics_save_path						)
         # Uncommenting this will save val generations
         # return self._write_logs(trainer, pl_module, "valid")






def      UpperCAmelCase_   (     __UpperCamelCase,    __UpperCamelCase,    __UpperCamelCase=1,    __UpperCamelCase=False     ):
    if metric == "rouge2":
        SCREAMING_SNAKE_CASE__       ="""{val_avg_rouge2:.4f}-{step_count}"""
    elif metric == "bleu":
        SCREAMING_SNAKE_CASE__       ="""{val_avg_bleu:.4f}-{step_count}"""
    elif metric == "loss":
        SCREAMING_SNAKE_CASE__       ="""{val_avg_loss:.4f}-{step_count}"""
    else:
        raise NotImplementedError(
            f"""seq2seq callbacks only support rouge2, bleu and loss, got {metric}, You can make your own by adding to"""
            """ this function."""     )

    SCREAMING_SNAKE_CASE__       =ModelCheckpoint(
        dirpath=__UpperCamelCase,    filename=__UpperCamelCase,    monitor=f"""val_{metric}""",    mode="""min""" if """loss""" in metric else """max""",    save_top_k=__UpperCamelCase,    )
    return checkpoint_callback




def      UpperCAmelCase_   (     __UpperCamelCase,    __UpperCamelCase     ):
    return EarlyStopping(
        monitor=f"""val_{metric}""",    mode="""min""" if """loss""" in metric else """max""",    patience=__UpperCamelCase,    verbose=__UpperCamelCase,    )






