


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 				__SCREAMING_SNAKE_CASE   (			A__   ):


      @staticmethod
      def        __lowerCamelCase			(							SCREAMING_SNAKE_CASE__		):
            lowercase			:   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__		)		)
            lowercase			:   List[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__		)		)
            lowercase			:   int					   =		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
            lowercase			:   str					   =		parser.add_parser(
                '''repo'''							,						help='''Deprecated: use `huggingface-cli` instead. Commands to interact with your huggingface.co repos.'''							,						)
            lowercase			:   str					   =		repo_parser.add_subparsers(
                help='''Deprecated: use `huggingface-cli` instead. huggingface.co repos related commands'''		)
            lowercase			:   Any					   =		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 				__SCREAMING_SNAKE_CASE   :
      A				:							str    							=     '\u001b[1m'
      A				:							Optional[Any]    							=     '\u001b[31m'
      A				:							int    							=     '\u001b[90m'
      A				:							Optional[Any]    							=     '\u001b[0m'


      @classmethod
      def        __lowerCamelCase			(							cls							,						SCREAMING_SNAKE_CASE__		):
            return f"""{cls._bold}{s}{cls._reset}"""


      @classmethod
      def        __lowerCamelCase			(							cls							,						SCREAMING_SNAKE_CASE__		):
            return f"""{cls._bold}{cls._red}{s}{cls._reset}"""






      @classmethod
      def        __lowerCamelCase			(							cls							,						SCREAMING_SNAKE_CASE__		):
            return f"""{cls._gray}{s}{cls._reset}"""





def 			__lowercase	(						_UpperCamelCase,    _UpperCamelCase     )    ->str:







      """simple docstring"""

      lowercase			:   Optional[Any]					   =		[max(len(str(_UpperCamelCase     )     ) for x in col     ) for col in zip(*_UpperCamelCase,    _UpperCamelCase     )]
      lowercase			:   str					   =		('''{{:{}}} ''' * len(_UpperCamelCase     )).format(*_UpperCamelCase     )
      lowercase			:   str					   =		[]
      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 				__SCREAMING_SNAKE_CASE   :


      def __init__(							self							,						SCREAMING_SNAKE_CASE__		):
            lowercase			:   Dict					   =		args







class 				__SCREAMING_SNAKE_CASE   (			A__   ):


      def        __lowerCamelCase			(							self		):
            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 				__SCREAMING_SNAKE_CASE   (			A__   ):


      def        __lowerCamelCase			(							self		):
            print(
                ANSI.red(
                    '''WARNING! `transformers-cli whoami` is deprecated and will be removed in v5. Please use '''
                    '''`huggingface-cli whoami` instead.'''		)		)
            lowercase			:   Union[str, Any]					   =		HfFolder.get_token()
            if token is None:
                  print('''Not logged in'''		)
                  exit()
            try:
                  lowercase   ,			lowercase			:   List[Any]					   =		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 				__SCREAMING_SNAKE_CASE   (			A__   ):


      def        __lowerCamelCase			(							self		):
            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 				__SCREAMING_SNAKE_CASE   (			A__   ):


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

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

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





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__a   				=      {
    '''configuration_decision_transformer''': [
        '''DECISION_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''DecisionTransformerConfig''',
    ],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __a   				=      [
      '''DECISION_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST''',
      '''DecisionTransformerGPT2Model''',
      '''DecisionTransformerGPT2PreTrainedModel''',
      '''DecisionTransformerModel''',
      '''DecisionTransformerPreTrainedModel''',
  ]


if TYPE_CHECKING:
  from .configuration_decision_transformer import (
      DECISION_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
      DecisionTransformerConfig,
  )

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_decision_transformer import (
        DECISION_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
        DecisionTransformerGPTaModel,
        DecisionTransformerGPTaPreTrainedModel,
        DecisionTransformerModel,
        DecisionTransformerPreTrainedModel,
    )


else:
  import sys

  __a   				=      _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

