


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 						snake_case			(       lowerCAmelCase__	):
			'''simple docstring'''

			@staticmethod
			def _lowercase (	lowerCAmelCase_     :     ArgumentParser					)					->					int:




								"""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 lowerCAmelCase_					: LoginCommand(lowerCAmelCase_					)					)
								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 lowerCAmelCase_					: WhoamiCommand(lowerCAmelCase_					)					)
								SCREAMING_SNAKE_CASE_	      =       parser.add_parser('''logout'''							,							help='''Log out'''					)
								logout_parser.set_defaults(func=lambda lowerCAmelCase_					: LogoutCommand(lowerCAmelCase_					)					)

								# 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=lowerCAmelCase_							,							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=lowerCAmelCase_							,							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 lowerCAmelCase_					: RepoCreateCommand(lowerCAmelCase_					)					)

class 						snake_case			:
			'''simple docstring'''

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

			@classmethod
			def _lowercase (	cls     :     Optional[int]							,							lowerCAmelCase_     :     Tuple					)					->					Tuple:




								"""simple docstring"""






								return F'''{cls._bold}{s}{cls._reset}'''

			@classmethod
			def _lowercase (	cls     :     Union[str, Any]							,							lowerCAmelCase_     :     Tuple					)					->					Optional[Any]:




								"""simple docstring"""






								return F'''{cls._bold}{cls._red}{s}{cls._reset}'''




			@classmethod
			def _lowercase (	cls     :     int							,							lowerCAmelCase_     :     List[str]					)					->					Union[str, Any]:




								"""simple docstring"""






								return F'''{cls._gray}{s}{cls._reset}'''







def 							UpperCAmelCase				(     UpperCAmelCase				,UpperCAmelCase      )->		str:







					'''simple docstring'''



					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 						snake_case			:
			'''simple docstring'''

			def __init__(	self     :     int							,							lowerCAmelCase_     :     List[str]					)					->					Tuple:




								"""simple docstring"""






								SCREAMING_SNAKE_CASE_	      =       args

class 						snake_case			(       lowerCAmelCase__	):
			'''simple docstring'''

			def _lowercase (	self     :     Dict					)					->					int:




								"""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 						snake_case			(       lowerCAmelCase__	):
			'''simple docstring'''

			def _lowercase (	self     :     List[Any]					)					->					Optional[Any]:




								"""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(lowerCAmelCase_					)
													print(lowerCAmelCase_					)
													if orgs:
																		print(ANSI.bold('''orgs: '''					)							,							''','''.join(lowerCAmelCase_					)					)
								except HTTPError as e:
													print(lowerCAmelCase_					)
													print(ANSI.red(e.response.text					)					)
													exit(1					)

class 						snake_case			(       lowerCAmelCase__	):
			'''simple docstring'''

			def _lowercase (	self     :     List[str]					)					->					Union[str, Any]:




								"""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 						snake_case			(       lowerCAmelCase__	):
			'''simple docstring'''

			def _lowercase (	self     :     Union[str, Any]					)					->					Optional[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(lowerCAmelCase_					)
								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(lowerCAmelCase_					)}'''					)

								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(lowerCAmelCase_							,							name=self.args.name							,							organization=self.args.organization					)
								except HTTPError as e:
													print(lowerCAmelCase_					)
													print(ANSI.red(e.response.text					)					)
													exit(1					)
								print('''\nYour repo now lives at:'''					)
								print(F'''  {ANSI.bold(lowerCAmelCase_					)}'''					)
								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_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


A_														=      {
    "configuration_switch_transformers": [
        "SWITCH_TRANSFORMERS_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "SwitchTransformersConfig",
        "SwitchTransformersOnnxConfig",
    ]
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		A_														=      [
		    "SWITCH_TRANSFORMERS_PRETRAINED_MODEL_ARCHIVE_LIST",
		    "SwitchTransformersEncoderModel",
		    "SwitchTransformersForConditionalGeneration",
		    "SwitchTransformersModel",
		    "SwitchTransformersPreTrainedModel",
		    "SwitchTransformersTop1Router",
		    "SwitchTransformersSparseMLP",
		]


if TYPE_CHECKING:
		from .configuration_switch_transformers import (
		    SWITCH_TRANSFORMERS_PRETRAINED_CONFIG_ARCHIVE_MAP,
		    SwitchTransformersConfig,
		    SwitchTransformersOnnxConfig,
		)

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_switch_transformers import (
				    SWITCH_TRANSFORMERS_PRETRAINED_MODEL_ARCHIVE_LIST,
				    SwitchTransformersEncoderModel,
				    SwitchTransformersForConditionalGeneration,
				    SwitchTransformersModel,
				    SwitchTransformersPreTrainedModel,
				    SwitchTransformersSparseMLP,
				    SwitchTransformersTopaRouter,
				)


else:
		import sys

		A_														=      _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)


