




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 	__snake_case				(      A__					:				ArgumentParser     )			->    Union[str, Any]:
           lowerCamelCase__ 					=			parser.add_parser('login'		,					help='Log in using the same credentials as on huggingface.co'     )
           login_parser.set_defaults(func=lambda A__     : LoginCommand(A__     )     )
           lowerCamelCase__ 					=			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__     )     )
           lowerCamelCase__ 					=			parser.add_parser('logout'		,					help='Log out'     )
           logout_parser.set_defaults(func=lambda A__     : LogoutCommand(A__     )     )

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

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




     @classmethod
     def 	__snake_case				(      cls					:				List[Any]		,					A__					:				List[Any]     )			->    str:
           return F"""{cls._bold}{s}{cls._reset}"""




     @classmethod
     def 	__snake_case				(      cls					:				int		,					A__					:				Dict     )			->    Any:
           return F"""{cls._bold}{cls._red}{s}{cls._reset}"""




     @classmethod
     def 	__snake_case				(      cls					:				Optional[int]		,					A__					:				str     )			->    Tuple:
           return F"""{cls._gray}{s}{cls._reset}"""

def      lowerCAmelCase_     (					lowerCamelCase:    List[List[Union[str, int]]]       ,			lowerCamelCase:    List[str]  )   ->     str:


      '''simple docstring'''




      lowerCamelCase__ 					=			[max(len(str(lowerCamelCase  )  ) for x in col  ) for col in zip(*lowerCamelCase       ,			lowerCamelCase  )]
      lowerCamelCase__ 					=			('{{:{}}} ' * len(lowerCamelCase  )).format(*lowerCamelCase  )
      lowerCamelCase__ 					=			[]
      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      A     :
     """simple docstring"""

     def __init__(      self					:				Optional[int]		,					A__					:				Union[str, Any]     )			->    List[Any]:
           lowerCamelCase__ 					=			args






class      A     (						_lowerCAmelCase						):
     """simple docstring"""

     def 	__snake_case				(      self					:				Any     )			->    Union[str, 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      A     (						_lowerCAmelCase						):
     """simple docstring"""

     def 	__snake_case				(      self					:				str     )			->    int:
           print(
               ANSI.red(
                   'WARNING! `transformers-cli whoami` is deprecated and will be removed in v5. Please use '
                   '`huggingface-cli whoami` instead.'     )     )
           lowerCamelCase__ 					=			HfFolder.get_token()
           if token is None:
                 print('Not logged in'     )
                 exit()
           try:
                 lowerCamelCase__					,						lowerCamelCase__ 					=			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      A     (						_lowerCAmelCase						):
     """simple docstring"""

     def 	__snake_case				(      self					:				int     )			->    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      A     (						_lowerCAmelCase						):
     """simple docstring"""

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

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

           if not self.args.yes:
                 lowerCamelCase__ 					=			input('Proceed? [Y/n] '     ).lower()
                 if not (choice == "" or choice == "y" or choice == "yes"):
                       print('Abort'     )
                       exit()
           try:
                 lowerCamelCase__ 					=			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(''     )





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__SCREAMING_SNAKE_CASE      :				int				      ={"""configuration_nat""": ["""NAT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """NatConfig"""]}


try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __SCREAMING_SNAKE_CASE      :				Optional[int]				      =[
          """NAT_PRETRAINED_MODEL_ARCHIVE_LIST""",
          """NatForImageClassification""",
          """NatModel""",
          """NatPreTrainedModel""",
          """NatBackbone""",
      ]

if TYPE_CHECKING:
      from .configuration_nat import NAT_PRETRAINED_CONFIG_ARCHIVE_MAP, NatConfig

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_nat import (
                NAT_PRETRAINED_MODEL_ARCHIVE_LIST,
                NatBackbone,
                NatForImageClassification,
                NatModel,
                NatPreTrainedModel,
            )

else:
      import sys

      __SCREAMING_SNAKE_CASE      :				Any				      =_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)