




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						(     UpperCamelCase_  ):






      @staticmethod
      def  lowerCamelCase (      lowercase_		:  ArgumentParser				)      ->		int:
             """simple docstring"""




             _lowerCamelCase :	str						=parser.add_parser('login'    ,     help='Log in using the same credentials as on huggingface.co'				)
             login_parser.set_defaults(func=lambda lowercase_				: LoginCommand(lowercase_				)				)
             _lowerCamelCase :	List[str]						=parser.add_parser('whoami'    ,     help='Find out which huggingface.co account you are logged in as.'				)
             whoami_parser.set_defaults(func=lambda lowercase_				: WhoamiCommand(lowercase_				)				)
             _lowerCamelCase :	Any						=parser.add_parser('logout'    ,     help='Log out'				)
             logout_parser.set_defaults(func=lambda lowercase_				: LogoutCommand(lowercase_				)				)

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




class A						:
      UpperCamelCase__							:						int   ='\u001b[1m'
      UpperCamelCase__							:						List[Any]   ='\u001b[31m'
      UpperCamelCase__							:						int   ='\u001b[90m'
      UpperCamelCase__							:						int   ='\u001b[0m'






      @classmethod
      def  lowerCamelCase (      cls		:  str    ,     lowercase_		:  Optional[int]				)      ->		str:
             """simple docstring"""




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






      @classmethod
      def  lowerCamelCase (      cls		:  Dict    ,     lowercase_		:  Optional[int]				)      ->		Any:
             """simple docstring"""




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






      @classmethod
      def  lowerCamelCase (      cls		:  List[str]    ,     lowercase_		:  Union[str, Any]				)      ->		Union[str, Any]:
             """simple docstring"""




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




def 			a_   (					SCREAMING_SNAKE_CASE__      :   List[List[Union[str, int]]]	,    SCREAMING_SNAKE_CASE__      :   List[str]  ):
       '''simple docstring'''





       _lowerCamelCase :	Optional[Any]						=[max(len(str(SCREAMING_SNAKE_CASE__  )  ) for x in col  ) for col in zip(*SCREAMING_SNAKE_CASE__	,    SCREAMING_SNAKE_CASE__  )]
       _lowerCamelCase :	Tuple						=('{{:{}}} ' * len(SCREAMING_SNAKE_CASE__  )).format(*SCREAMING_SNAKE_CASE__  )
       _lowerCamelCase :	List[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 A						:






      def __init__(      self		:  Tuple    ,     lowercase_		:  Union[str, Any]				)      ->		Optional[Any]:
             """simple docstring"""




             _lowerCamelCase :	List[str]						=args




class A						(     UpperCamelCase_  ):






      def  lowerCamelCase (      self		:  List[Any]				)      ->		List[str]:
             """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 A						(     UpperCamelCase_  ):






      def  lowerCamelCase (      self		:  Optional[int]				)      ->		Union[str, Any]:
             """simple docstring"""




             print(
                 ANSI.red(
                     'WARNING! `transformers-cli whoami` is deprecated and will be removed in v5. Please use '
                     '`huggingface-cli whoami` instead.'				)				)
             _lowerCamelCase :	Optional[Any]						=HfFolder.get_token()
             if token is None:
                    print('Not logged in'				)
                    exit()
             try:
                    _lowerCamelCase :	Any						=whoami(lowercase_				)
                    print(lowercase_				)
                    if orgs:
                           print(ANSI.bold('orgs: '				)    ,     ','.join(lowercase_				)				)
             except HTTPError as e:
                    print(lowercase_				)
                    print(ANSI.red(e.response.text				)				)
                    exit(1				)




class A						(     UpperCamelCase_  ):






      def  lowerCamelCase (      self		:  int				)      ->		str:
             """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 A						(     UpperCamelCase_  ):






      def  lowerCamelCase (      self		:  Dict				)      ->		List[str]:
             """simple docstring"""




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

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

             if not self.args.yes:
                    _lowerCamelCase :	Union[str, Any]						=input('Proceed? [Y/n] '				).lower()
                    if not (choice == "" or choice == "y" or choice == "yes"):
                           print('Abort'				)
                           exit()
             try:
                    _lowerCamelCase :	List[Any]						=create_repo(lowercase_    ,     name=self.args.name    ,     organization=self.args.organization				)
             except HTTPError as e:
                    print(lowercase_				)
                    print(ANSI.red(e.response.text				)				)
                    exit(1				)
             print('\nYour repo now lives at:'				)
             print(F'''  {ANSI.bold(lowercase_				)}'''				)
             print('\nYou can clone it locally with the command below, and commit/push as usual.'				)
             print(F'''\n  git clone {url}'''				)
             print(''				)






import unittest

from transformers import ErnieMConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
 import torch

 from transformers import (
     ErnieMForInformationExtraction,
     ErnieMForMultipleChoice,
     ErnieMForQuestionAnswering,
     ErnieMForSequenceClassification,
     ErnieMForTokenClassification,
     ErnieMModel,
 )
 from transformers.models.ernie_m.modeling_ernie_m import ERNIE_M_PRETRAINED_MODEL_ARCHIVE_LIST




class A						:






      def __init__(      self		:  int    ,     lowercase_		:  List[Any]    ,     lowercase_		:  Dict=13    ,     lowercase_		:  Optional[Any]=7    ,     lowercase_		:  List[str]=True    ,     lowercase_		:  List[str]=True    ,     lowercase_		:  Tuple=True    ,     lowercase_		:  Union[str, Any]=99    ,     lowercase_		:  Union[str, Any]=32    ,     lowercase_		:  Tuple=5    ,     lowercase_		:  List[Any]=4    ,     lowercase_		:  Any=37    ,     lowercase_		:  Union[str, Any]="gelu"    ,     lowercase_		:  Any=0.1    ,     lowercase_		:  Union[str, Any]=0.1    ,     lowercase_		:  List[str]=512    ,     lowercase_		:  Optional[int]=16    ,     lowercase_		:  int=2    ,     lowercase_		:  Optional[Any]=0.02    ,     lowercase_		:  Dict=3    ,     lowercase_		:  Any=4    ,     lowercase_		:  List[str]=None    ,     )      ->		Tuple:
             """simple docstring"""




             _lowerCamelCase :	Dict						=parent
             _lowerCamelCase :	Optional[int]						=batch_size
             _lowerCamelCase :	int						=seq_length
             _lowerCamelCase :	List[str]						=is_training
             _lowerCamelCase :	Optional[int]						=use_input_mask
             _lowerCamelCase :	Dict						=use_labels
             _lowerCamelCase :	Any						=vocab_size
             _lowerCamelCase :	Any						=hidden_size
             _lowerCamelCase :	Any						=num_hidden_layers
             _lowerCamelCase :	Optional[int]						=num_attention_heads
             _lowerCamelCase :	Optional[Any]						=intermediate_size
             _lowerCamelCase :	Union[str, Any]						=hidden_act
             _lowerCamelCase :	str						=hidden_dropout_prob
             _lowerCamelCase :	Tuple						=attention_probs_dropout_prob
             _lowerCamelCase :	Tuple						=max_position_embeddings
             _lowerCamelCase :	Optional[int]						=type_vocab_size
             _lowerCamelCase :	Optional[Any]						=type_sequence_label_size
             _lowerCamelCase :	List[str]						=initializer_range
             _lowerCamelCase :	Dict						=num_labels
             _lowerCamelCase :	List[str]						=num_choices
             _lowerCamelCase :	Optional[Any]						=scope






      def  lowerCamelCase (      self		:  Optional[Any]				)      ->		Tuple:
             """simple docstring"""




             _lowerCamelCase :	Union[str, Any]						=ids_tensor([self.batch_size, self.seq_length]    ,     self.vocab_size				)

             _lowerCamelCase :	List[str]						=None
             if self.use_input_mask:
                    _lowerCamelCase :	Union[str, Any]						=random_attention_mask([self.batch_size, self.seq_length]				)

             _lowerCamelCase :	Any						=None
             _lowerCamelCase :	int						=None
             _lowerCamelCase :	int						=None
             if self.use_labels:
                    _lowerCamelCase :	Optional[int]						=ids_tensor([self.batch_size]    ,     self.type_sequence_label_size				)
                    _lowerCamelCase :	List[str]						=ids_tensor([self.batch_size, self.seq_length]    ,     self.num_labels				)
                    _lowerCamelCase :	Optional[Any]						=ids_tensor([self.batch_size]    ,     self.num_choices				)

             _lowerCamelCase :	Any						=self.get_config()

             return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels






      def  lowerCamelCase (      self		:  Dict				)      ->		Dict:
             """simple docstring"""




             _lowerCamelCase :	List[str]						=ids_tensor([self.batch_size, self.seq_length]    ,     self.vocab_size				)

             _lowerCamelCase :	str						=None
             if self.use_input_mask:
                    _lowerCamelCase :	Union[str, Any]						=random_attention_mask([self.batch_size, self.seq_length]				)
             _lowerCamelCase :	str						=self.get_config()

             return config, input_ids, input_mask






      def  lowerCamelCase (      self		:  Any				)      ->		Any:
             """simple docstring"""




             return ErnieMConfig(
                 vocab_size=self.vocab_size    ,     hidden_size=self.hidden_size    ,     num_hidden_layers=self.num_hidden_layers    ,     num_attention_heads=self.num_attention_heads    ,     intermediate_size=self.intermediate_size    ,     hidden_act=self.hidden_act    ,     hidden_dropout_prob=self.hidden_dropout_prob    ,     attention_probs_dropout_prob=self.attention_probs_dropout_prob    ,     max_position_embeddings=self.max_position_embeddings    ,     type_vocab_size=self.type_vocab_size    ,     initializer_range=self.initializer_range    ,     )






      def  lowerCamelCase (      self		:  Optional[int]    ,     lowercase_		:  Tuple    ,     lowercase_		:  Tuple    ,     lowercase_		:  Any    ,     lowercase_		:  Dict    ,     lowercase_		:  int    ,     lowercase_		:  Tuple				)      ->		List[str]:
             """simple docstring"""




             _lowerCamelCase :	Tuple						=ErnieMModel(config=lowercase_				)
             model.to(lowercase_				)
             model.eval()
             _lowerCamelCase :	str						=model(lowercase_    ,     return_dict=lowercase_				)
             self.parent.assertEqual(result.last_hidden_state.shape    ,     (self.batch_size, self.seq_length, self.hidden_size)				)






      def  lowerCamelCase (      self		:  str    ,     lowercase_		:  Union[str, Any]    ,     lowercase_		:  Union[str, Any]    ,     lowercase_		:  List[str]    ,     lowercase_		:  str    ,     lowercase_		:  List[str]    ,     lowercase_		:  str				)      ->		str:
             """simple docstring"""




             _lowerCamelCase :	Any						=ErnieMForQuestionAnswering(config=lowercase_				)
             model.to(lowercase_				)
             model.eval()
             _lowerCamelCase :	List[str]						=model(
                 lowercase_    ,     attention_mask=lowercase_    ,     start_positions=lowercase_    ,     end_positions=lowercase_    ,     )
             self.parent.assertEqual(result.start_logits.shape    ,     (self.batch_size, self.seq_length)				)
             self.parent.assertEqual(result.end_logits.shape    ,     (self.batch_size, self.seq_length)				)






      def  lowerCamelCase (      self		:  int    ,     lowercase_		:  List[Any]    ,     lowercase_		:  int    ,     lowercase_		:  Optional[int]    ,     lowercase_		:  Optional[Any]    ,     lowercase_		:  Any    ,     lowercase_		:  Optional[int]				)      ->		Any:
             """simple docstring"""




             _lowerCamelCase :	Union[str, Any]						=ErnieMForInformationExtraction(config=lowercase_				)
             model.to(lowercase_				)
             model.eval()
             _lowerCamelCase :	Optional[int]						=torch.ones_like(lowercase_    ,     dtype=torch.floataa				)
             _lowerCamelCase :	str						=model(
                 lowercase_    ,     attention_mask=lowercase_    ,     start_positions=lowercase_    ,     end_positions=lowercase_    ,     )
             self.parent.assertEqual(result.start_logits.shape    ,     (self.batch_size, self.seq_length)				)
             self.parent.assertEqual(result.end_logits.shape    ,     (self.batch_size, self.seq_length)				)






      def  lowerCamelCase (      self		:  Dict    ,     lowercase_		:  Dict    ,     lowercase_		:  Tuple    ,     lowercase_		:  List[str]    ,     lowercase_		:  str    ,     lowercase_		:  Any    ,     lowercase_		:  Tuple				)      ->		int:
             """simple docstring"""




             _lowerCamelCase :	Dict						=self.num_labels
             _lowerCamelCase :	Any						=ErnieMForSequenceClassification(lowercase_				)
             model.to(lowercase_				)
             model.eval()
             _lowerCamelCase :	Optional[int]						=model(lowercase_    ,     attention_mask=lowercase_    ,     labels=lowercase_				)
             self.parent.assertEqual(result.logits.shape    ,     (self.batch_size, self.num_labels)				)






      def  lowerCamelCase (      self		:  Dict    ,     lowercase_		:  List[str]    ,     lowercase_		:  Optional[Any]    ,     lowercase_		:  Optional[int]    ,     lowercase_		:  List[str]    ,     lowercase_		:  Optional[int]    ,     lowercase_		:  Dict				)      ->		int:
             """simple docstring"""




             _lowerCamelCase :	int						=self.num_labels
             _lowerCamelCase :	List[str]						=ErnieMForTokenClassification(config=lowercase_				)
             model.to(lowercase_				)
             model.eval()
             input_ids.to(lowercase_				)
             input_mask.to(lowercase_				)
             token_labels.to(lowercase_				)

             _lowerCamelCase :	List[Any]						=model(lowercase_    ,     attention_mask=lowercase_    ,     labels=lowercase_				)

             self.parent.assertEqual(result.logits.shape    ,     (self.batch_size, self.seq_length, self.num_labels)				)






      def  lowerCamelCase (      self		:  Union[str, Any]    ,     lowercase_		:  int    ,     lowercase_		:  Union[str, Any]    ,     lowercase_		:  int    ,     lowercase_		:  str    ,     lowercase_		:  Optional[int]    ,     lowercase_		:  str				)      ->		Tuple:
             """simple docstring"""




             _lowerCamelCase :	Any						=self.num_choices
             _lowerCamelCase :	Any						=ErnieMForMultipleChoice(config=lowercase_				)
             model.to(lowercase_				)
             model.eval()
             _lowerCamelCase :	str						=input_ids.unsqueeze(1				).expand(-1    ,     self.num_choices    ,     -1				).contiguous()
             _lowerCamelCase :	Optional[int]						=input_mask.unsqueeze(1				).expand(-1    ,     self.num_choices    ,     -1				).contiguous()
             _lowerCamelCase :	List[str]						=model(
                 lowercase_    ,     attention_mask=lowercase_    ,     labels=lowercase_    ,     )
             self.parent.assertEqual(result.logits.shape    ,     (self.batch_size, self.num_choices)				)






      def  lowerCamelCase (      self		:  Union[str, Any]				)      ->		List[str]:
             """simple docstring"""




             _lowerCamelCase :	Tuple						=self.prepare_config_and_inputs()
             (
                 (
                 _lowerCamelCase
             )			,  (
                 _lowerCamelCase
             )			,  (
                 _lowerCamelCase
             )			,  (
                 _lowerCamelCase
             )			,  (
                 _lowerCamelCase
             )			,  (
                 _lowerCamelCase
             )			,  
             ) :	List[Any]						=config_and_inputs
             _lowerCamelCase :	Optional[Any]						={'input_ids': input_ids, 'attention_mask': input_mask}
             return config, inputs_dict




@require_torch
class A						(     UpperCamelCase_					,							UpperCamelCase_					,							unittest.TestCase  ):
      UpperCamelCase__							:						str   =(
          (
              ErnieMModel,
              ErnieMForMultipleChoice,
              ErnieMForQuestionAnswering,
              ErnieMForSequenceClassification,
              ErnieMForTokenClassification,
          )
          if is_torch_available()
          else ()
      )
      UpperCamelCase__							:						Dict   =()
      UpperCamelCase__							:						List[str]   =(
          {
              'feature-extraction': ErnieMModel,
              'question-answering': ErnieMForQuestionAnswering,
              'text-classification': ErnieMForSequenceClassification,
              'token-classification': ErnieMForTokenClassification,
              'zero-shot': ErnieMForSequenceClassification,
          }
          if is_torch_available()
          else {}
      )
      UpperCamelCase__							:						List[str]   =False






      def  lowerCamelCase (      self		:  str    ,     lowercase_		:  List[Any]    ,     lowercase_		:  Any    ,     lowercase_		:  str    ,     lowercase_		:  Tuple    ,     lowercase_		:  Tuple				)      ->		Dict:
             """simple docstring"""




             if pipeline_test_casse_name == "QAPipelineTests":
                    return True

             return False






      def  lowerCamelCase (      self		:  Union[str, Any]				)      ->		int:
             """simple docstring"""




             _lowerCamelCase :	int						=ErnieMModelTester(self				)
             _lowerCamelCase :	Optional[int]						=ConfigTester(self    ,     config_class=lowercase_    ,     hidden_size=37				)






      def  lowerCamelCase (      self		:  Optional[Any]				)      ->		Union[str, Any]:
             """simple docstring"""




             self.config_tester.run_common_tests()






      def  lowerCamelCase (      self		:  Optional[int]				)      ->		Dict:
             """simple docstring"""




             _lowerCamelCase :	Union[str, Any]						=self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_model(*lowercase_				)






      def  lowerCamelCase (      self		:  Dict				)      ->		Optional[Any]:
             """simple docstring"""




             _lowerCamelCase :	List[Any]						=self.model_tester.prepare_config_and_inputs()
             for type in ["absolute", "relative_key", "relative_key_query"]:
                    _lowerCamelCase :	Optional[Any]						=type
                    self.model_tester.create_and_check_model(*lowercase_				)






      def  lowerCamelCase (      self		:  Tuple				)      ->		Any:
             """simple docstring"""




             _lowerCamelCase :	Optional[Any]						=self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_multiple_choice(*lowercase_				)






      def  lowerCamelCase (      self		:  str				)      ->		Tuple:
             """simple docstring"""




             _lowerCamelCase :	Dict						=self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_question_answering(*lowercase_				)






      def  lowerCamelCase (      self		:  List[str]				)      ->		Union[str, Any]:
             """simple docstring"""




             _lowerCamelCase :	Any						=self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_sequence_classification(*lowercase_				)






      def  lowerCamelCase (      self		:  List[str]				)      ->		Union[str, Any]:
             """simple docstring"""




             _lowerCamelCase :	List[str]						=self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_information_extraction(*lowercase_				)






      def  lowerCamelCase (      self		:  Optional[Any]				)      ->		Tuple:
             """simple docstring"""




             _lowerCamelCase :	str						=self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_token_classification(*lowercase_				)






      @slow
      def  lowerCamelCase (      self		:  Union[str, Any]				)      ->		List[str]:
             """simple docstring"""




             for model_name in ERNIE_M_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                    _lowerCamelCase :	Union[str, Any]						=ErnieMModel.from_pretrained(lowercase_				)
                    self.assertIsNotNone(lowercase_				)




@require_torch
class A						(     unittest.TestCase  ):






      @slow
      def  lowerCamelCase (      self		:  List[str]				)      ->		Dict:
             """simple docstring"""




             _lowerCamelCase :	Dict						=ErnieMModel.from_pretrained('susnato/ernie-m-base_pytorch'				)
             model.eval()
             _lowerCamelCase :	Optional[int]						=torch.tensor([[0, 1, 2, 3, 4, 5]]				)
             _lowerCamelCase :	Optional[int]						=model(lowercase_				)[0]

             # TODO Replace vocab size
             _lowerCamelCase :	Optional[Any]						=768

             _lowerCamelCase :	str						=torch.Size((1, 6, hidden_size)				)
             self.assertEqual(output.shape    ,     lowercase_				)

             _lowerCamelCase :	str						=torch.tensor(
                 [[[-0.0012, 0.1245, -0.0214], [-0.0742, 0.0244, -0.0771], [-0.0333, 0.1164, -0.1554]]]				)

             self.assertTrue(torch.allclose(output[:, :3, :3]    ,     lowercase_    ,     atol=1E-3				)				)


