code: 
  
  
  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(''''''					)
  
  
  
style_context: 
  
  
  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__)
  
  
  