


'''simple docstring'''







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 				__lowerCamelCase				( __lowerCamelCase ):
    """simple docstring"""


    @staticmethod
    def      A					(						SCREAMING_SNAKE_CASE    :							ArgumentParser):
           _A  :			Optional[int]											=      parser.add_parser('login'   ,							help='Log in using the same credentials as on huggingface.co')
           login_parser.set_defaults(func=lambda SCREAMING_SNAKE_CASE: LoginCommand(SCREAMING_SNAKE_CASE))
           _A  :			Union[str, Any]											=      parser.add_parser('whoami'   ,							help='Find out which huggingface.co account you are logged in as.')
           whoami_parser.set_defaults(func=lambda SCREAMING_SNAKE_CASE: WhoamiCommand(SCREAMING_SNAKE_CASE))
           _A  :			Optional[Any]											=      parser.add_parser('logout'   ,							help='Log out')
           logout_parser.set_defaults(func=lambda SCREAMING_SNAKE_CASE: LogoutCommand(SCREAMING_SNAKE_CASE))

           # new system: git-based repo system
           _A  :			Tuple											=      parser.add_parser(
               'repo'   ,							help='Deprecated: use `huggingface-cli` instead. Commands to interact with your huggingface.co repos.'   ,							)
           _A  :			Union[str, Any]											=      repo_parser.add_subparsers(
               help='Deprecated: use `huggingface-cli` instead. huggingface.co repos related commands')
           _A  :			Optional[int]											=      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=SCREAMING_SNAKE_CASE   ,							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=SCREAMING_SNAKE_CASE   ,							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 SCREAMING_SNAKE_CASE: RepoCreateCommand(SCREAMING_SNAKE_CASE))




class 				__lowerCamelCase				:
    """simple docstring"""
    a									=					'\u001b[1m'
    a									=					'\u001b[31m'
    a									=					'\u001b[90m'
    a									=					'\u001b[0m'


    @classmethod
    def      A					(						cls    :							List[Any]   ,							SCREAMING_SNAKE_CASE    :							Any):
           return F'{cls._bold}{s}{cls._reset}'


    @classmethod
    def      A					(						cls    :							Optional[Any]   ,							SCREAMING_SNAKE_CASE    :							str):
           return F'{cls._bold}{cls._red}{s}{cls._reset}'


    @classmethod
    def      A					(						cls    :							List[str]   ,							SCREAMING_SNAKE_CASE    :							Any):
           return F'{cls._gray}{s}{cls._reset}'






def    lowerCAmelCase__ (       lowerCamelCase  :    Dict						,lowerCamelCase  :    Optional[int]     ):
       _A  :			List[Any]											=      [max(len(str(lowerCamelCase     )     ) for x in col     ) for col in zip(*lowerCamelCase						,lowerCamelCase     )]
       _A  :			Dict											=      ('{{:{}}} ' * len(lowerCamelCase     )).format(*lowerCamelCase     )
       _A  :			Dict											=      []
       lines.append(row_format.format(*lowerCamelCase     )     )
       lines.append(row_format.format(*['-' * w for w in col_widths]     )     )
       for row in rows:
              lines.append(row_format.format(*lowerCamelCase     )     )
       return "\n".join(lowerCamelCase     )


class 				__lowerCamelCase				:
    """simple docstring"""


    def __init__(						self    :							List[str]   ,							SCREAMING_SNAKE_CASE    :							Optional[Any]):
           _A  :			Dict											=      args




class 				__lowerCamelCase				( __lowerCamelCase ):
    """simple docstring"""


    def      A					(						self    :							List[str]):
           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 				__lowerCamelCase				( __lowerCamelCase ):
    """simple docstring"""


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




class 				__lowerCamelCase				( __lowerCamelCase ):
    """simple docstring"""


    def      A					(						self    :							str):
           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 				__lowerCamelCase				( __lowerCamelCase ):
    """simple docstring"""


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

           _A						,				_A  :			Optional[Any]											=      whoami(SCREAMING_SNAKE_CASE)
           _A  :			Any											=      self.args.organization if self.args.organization is not None else user
           _A  :			Any											=      F'{namespace}/{self.args.name}'
           print(F'You are about to create {ANSI.bold(SCREAMING_SNAKE_CASE)}')

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










'''simple docstring'''







A   :  Optional[Any]       		=				{
    '''0000''': '''0''',
    '''0001''': '''1''',
    '''0010''': '''2''',
    '''0011''': '''3''',
    '''0100''': '''4''',
    '''0101''': '''5''',
    '''0110''': '''6''',
    '''0111''': '''7''',
    '''1000''': '''8''',
    '''1001''': '''9''',
    '''1010''': '''a''',
    '''1011''': '''b''',
    '''1100''': '''c''',
    '''1101''': '''d''',
    '''1110''': '''e''',
    '''1111''': '''f''',
}






def    lowerCAmelCase__ (       lowerCamelCase  :    str     ):
       _A  :			Union[str, Any]											=      str(lowerCamelCase     ).strip()

       # Exceptions
       if not binary_str:
              raise ValueError('Empty string was passed to the function'     )
       _A  :			Any											=      binary_str[0] == '-'
       _A  :			str											=      binary_str[1:] if is_negative else binary_str
       if not all(char in '01' for char in binary_str     ):
              raise ValueError('Non-binary value was passed to the function'     )

       _A  :			Optional[Any]											=      (
           '0' * (4 * (divmod(len(lowerCamelCase     )						,4     )[0] + 1) - len(lowerCamelCase     )) + binary_str
       )

       _A  :			Optional[int]											=      []
       for x in range(0						,len(lowerCamelCase     )						,4     ):
              hexadecimal.append(BITS_TO_HEX[binary_str[x : x + 4]]     )
       _A  :			int											=      '0x' + ''.join(lowerCamelCase     )

       return "-" + hexadecimal_str if is_negative else hexadecimal_str


if __name__ == "__main__":
   from doctest import testmod

   testmod()






