




"""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    __lowercase							(      A_						):


				'''simple docstring'''


				@staticmethod
				def    _lowerCamelCase       ( SCREAMING_SNAKE_CASE_ :  Tuple   ):
										snake_case__							:       Tuple				      =       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(A_   )   )
										snake_case__							:       str				      =       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(A_   )   )
										snake_case__							:       List[Any]				      =       parser.add_parser('''logout'''   ,help='''Log out'''   )
										logout_parser.set_defaults(func=lambda SCREAMING_SNAKE_CASE_   : LogoutCommand(A_   )   )

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







class    __lowercase							:


				'''simple docstring'''


				_lowerCAmelCase						      ="\u001b[1m"
				_lowerCAmelCase						      ="\u001b[31m"
				_lowerCAmelCase						      ="\u001b[90m"
				_lowerCAmelCase						      ="\u001b[0m"

				@classmethod
				def    _lowerCamelCase       ( cls :  int   ,SCREAMING_SNAKE_CASE_ :  List[str]   ):
										return F'''{cls._bold}{s}{cls._reset}'''

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





				@classmethod
				def    _lowerCamelCase       ( cls :  str   ,SCREAMING_SNAKE_CASE_ :  Any   ):
										return F'''{cls._gray}{s}{cls._reset}'''







def 		lowerCAmelCase				(			lowerCamelCase   ,      lowerCamelCase		):
						'''simple docstring'''


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

class    __lowercase							:


				'''simple docstring'''


				def __init__( self :  Optional[int]   ,SCREAMING_SNAKE_CASE_ :  Any   ):
										snake_case__							:       int				      =       args







class    __lowercase							(      A_						):


				'''simple docstring'''


				def    _lowerCamelCase       ( 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    __lowercase							(      A_						):


				'''simple docstring'''


				def    _lowerCamelCase       ( self :  Any   ):
										print(
										    ANSI.red(
										        '''WARNING! `transformers-cli whoami` is deprecated and will be removed in v5. Please use '''
										        '''`huggingface-cli whoami` instead.'''   )   )
										snake_case__							:       Any				      =       HfFolder.get_token()
										if token is None:
																print('''Not logged in'''   )
																exit()
										try:
																snake_case__      ,						snake_case__							:       Tuple				      =       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    __lowercase							(      A_						):


				'''simple docstring'''


				def    _lowerCamelCase       ( self :  Union[str, Any]   ):
										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    __lowercase							(      A_						):


				'''simple docstring'''


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

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

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






def 		_UpperCAmelCase							(     SCREAMING_SNAKE_CASE__     :   list     ,	SCREAMING_SNAKE_CASE__     :   int     ,	SCREAMING_SNAKE_CASE__     :   int     ,	SCREAMING_SNAKE_CASE__     :   int							):
     __UpperCamelCase       				=int((lower_bound + upper_bound) // 2							)
     if array[r] == value:
          return r
     if lower_bound >= upper_bound:
          return -1
     if array[r] < value:
          return binary_search(SCREAMING_SNAKE_CASE__     ,	r + 1     ,	SCREAMING_SNAKE_CASE__     ,	SCREAMING_SNAKE_CASE__							)
     else:
          return binary_search(SCREAMING_SNAKE_CASE__     ,	SCREAMING_SNAKE_CASE__     ,	r - 1     ,	SCREAMING_SNAKE_CASE__							)

def 		_UpperCAmelCase							(     SCREAMING_SNAKE_CASE__     :   int     ,	SCREAMING_SNAKE_CASE__     :   list							):
     __UpperCamelCase       				=0
     if matrix[index][0] == value:
          return [index, 0]
     while index < len(SCREAMING_SNAKE_CASE__							) and matrix[index][0] < value:
          __UpperCamelCase       				=binary_search(matrix[index]     ,	0     ,	len(matrix[index]							) - 1     ,	SCREAMING_SNAKE_CASE__							)
          if r != -1:
               return [index, r]
          index += 1
     return [-1, -1]


if __name__ == "__main__":
   import doctest

   doctest.testmod()





