


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        UpperCAmelCase__			(   A_						):



    """simple docstring"""






    @staticmethod
    def _a   (     A_       )    ->			Dict:
         __UpperCamelCase       				=parser.add_parser('login'   ,  help='Log in using the same credentials as on huggingface.co'       )
         login_parser.set_defaults(func=lambda A_       : LoginCommand(A_       )       )
         __UpperCamelCase       				=parser.add_parser('whoami'   ,  help='Find out which huggingface.co account you are logged in as.'       )
         whoami_parser.set_defaults(func=lambda A_       : WhoamiCommand(A_       )       )
         __UpperCamelCase       				=parser.add_parser('logout'   ,  help='Log out'       )
         logout_parser.set_defaults(func=lambda A_       : LogoutCommand(A_       )       )

         # new system: git-based repo system
         __UpperCamelCase       				=parser.add_parser(
             'repo'   ,  help='Deprecated: use `huggingface-cli` instead. Commands to interact with your huggingface.co repos.'   ,  )
         __UpperCamelCase       				=repo_parser.add_subparsers(
             help='Deprecated: use `huggingface-cli` instead. huggingface.co repos related commands'       )
         __UpperCamelCase       				=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=A_   ,  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=A_   ,  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 A_       : RepoCreateCommand(A_       )       )






class        UpperCAmelCase__			:



    """simple docstring"""






    UpperCAmelCase__		:						List[Any]    =    "\u001b[1m"
    UpperCAmelCase__		:						Dict    =    "\u001b[31m"
    UpperCAmelCase__		:						Union[str, Any]    =    "\u001b[90m"
    UpperCAmelCase__		:						Dict    =    "\u001b[0m"






    @classmethod
    def _a   (     cls   ,  A_       )    ->			Any:
         return f'{cls._bold}{s}{cls._reset}'






    @classmethod
    def _a   (     cls   ,  A_       )    ->			Optional[int]:
         return f'{cls._bold}{cls._red}{s}{cls._reset}'






    @classmethod
    def _a   (     cls   ,  A_       )    ->			Dict:
         return f'{cls._gray}{s}{cls._reset}'

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






class        UpperCAmelCase__			:



    """simple docstring"""






    def __init__(     self   ,  A_       )    ->			Tuple:
         __UpperCamelCase       				=args






class        UpperCAmelCase__			(   A_						):



    """simple docstring"""






    def _a   (     self       )    ->			Any:
         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        UpperCAmelCase__			(   A_						):



    """simple docstring"""






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






class        UpperCAmelCase__			(   A_						):



    """simple docstring"""






    def _a   (     self       )    ->			Tuple:
         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        UpperCAmelCase__			(   A_						):



    """simple docstring"""






    def _a   (     self       )    ->			Any:
         print(
             ANSI.red(
                 'WARNING! Managing repositories through transformers-cli is deprecated. '
                 'Please use `huggingface-cli` instead.'       )       )
         __UpperCamelCase       				=HfFolder.get_token()
         if token is None:
              print('Not logged in'       )
              exit(1       )
         try:
              __UpperCamelCase       				=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:
              __UpperCamelCase       				=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(''       )

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

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









def 		_UpperCAmelCase							(     SCREAMING_SNAKE_CASE__     :   list     ,	SCREAMING_SNAKE_CASE__     :   int     ,	SCREAMING_SNAKE_CASE__     :   int     ,	SCREAMING_SNAKE_CASE__     :   int							):
     __UpperCamelCase       				=int((lower_bound + upper_bound) // 2							)
     if array[r] == value:
          return r
     if lower_bound >= upper_bound:
          return -1
     if array[r] < value:
          return binary_search(SCREAMING_SNAKE_CASE__     ,	r + 1     ,	SCREAMING_SNAKE_CASE__     ,	SCREAMING_SNAKE_CASE__							)
     else:
          return binary_search(SCREAMING_SNAKE_CASE__     ,	SCREAMING_SNAKE_CASE__     ,	r - 1     ,	SCREAMING_SNAKE_CASE__							)

def 		_UpperCAmelCase							(     SCREAMING_SNAKE_CASE__     :   int     ,	SCREAMING_SNAKE_CASE__     :   list							):
     __UpperCamelCase       				=0
     if matrix[index][0] == value:
          return [index, 0]
     while index < len(SCREAMING_SNAKE_CASE__							) and matrix[index][0] < value:
          __UpperCamelCase       				=binary_search(matrix[index]     ,	0     ,	len(matrix[index]							) - 1     ,	SCREAMING_SNAKE_CASE__							)
          if r != -1:
               return [index, r]
          index += 1
     return [-1, -1]


if __name__ == "__main__":
   import doctest

   doctest.testmod()





