


"""simple docstring"""




from __future__ import annotations

import unittest

from transformers import CTRLConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
    import tensorflow as tf

    from transformers.models.ctrl.modeling_tf_ctrl import (
        TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFCTRLForSequenceClassification,
        TFCTRLLMHeadModel,
        TFCTRLModel,
    )



class 					__lowerCamelCase	(_a		):







       def __init__(	self:				List[str],A_:				Any,):






            '''simple docstring'''




            __UpperCamelCase				=	parent
            __UpperCamelCase				=	13
            __UpperCamelCase				=	7
            __UpperCamelCase				=	True
            __UpperCamelCase				=	True
            __UpperCamelCase				=	True
            __UpperCamelCase				=	True
            __UpperCamelCase				=	True
            __UpperCamelCase				=	99
            __UpperCamelCase				=	32
            __UpperCamelCase				=	2
            __UpperCamelCase				=	4
            __UpperCamelCase				=	37
            __UpperCamelCase				=	'gelu'
            __UpperCamelCase				=	0.1
            __UpperCamelCase				=	0.1
            __UpperCamelCase				=	512
            __UpperCamelCase				=	16
            __UpperCamelCase				=	2
            __UpperCamelCase				=	0.0_2
            __UpperCamelCase				=	3
            __UpperCamelCase				=	4
            __UpperCamelCase				=	None
            __UpperCamelCase				=	self.vocab_size - 1







       def 						snake_case_					(	self:				Dict			):






            '''simple docstring'''




            __UpperCamelCase				=	ids_tensor([self.batch_size, self.seq_length],self.vocab_size			)

            __UpperCamelCase				=	None
            if self.use_input_mask:
                 __UpperCamelCase				=	random_attention_mask([self.batch_size, self.seq_length]			)

            __UpperCamelCase				=	None
            if self.use_token_type_ids:
                 __UpperCamelCase				=	ids_tensor([self.batch_size, self.seq_length],self.type_vocab_size			)

            __UpperCamelCase				=	None
            if self.use_mc_token_ids:
                 __UpperCamelCase				=	ids_tensor([self.batch_size, self.num_choices],self.seq_length			)

            __UpperCamelCase				=	None
            __UpperCamelCase				=	None
            __UpperCamelCase				=	None
            if self.use_labels:
                 __UpperCamelCase				=	ids_tensor([self.batch_size],self.type_sequence_label_size			)
                 __UpperCamelCase				=	ids_tensor([self.batch_size, self.seq_length],self.num_labels			)
                 __UpperCamelCase				=	ids_tensor([self.batch_size],self.num_choices			)

            __UpperCamelCase				=	CTRLConfig(
                vocab_size=self.vocab_size,n_embd=self.hidden_size,n_layer=self.num_hidden_layers,n_head=self.num_attention_heads,n_positions=self.max_position_embeddings,pad_token_id=self.pad_token_id,)

            __UpperCamelCase				=	ids_tensor([self.num_hidden_layers, self.num_attention_heads],2			)

            return (
                config,
                input_ids,
                input_mask,
                head_mask,
                token_type_ids,
                mc_token_ids,
                sequence_labels,
                token_labels,
                choice_labels,
            )







       def 						snake_case_					(	self:				Dict,A_:				List[Any],A_:				Optional[Any],A_:				Tuple,A_:				List[Any],A_:				Any,*A_:				Dict			):






            '''simple docstring'''




            __UpperCamelCase				=	TFCTRLModel(config=A_			)
            __UpperCamelCase				=	{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
            __UpperCamelCase				=	model(A_			)

            __UpperCamelCase				=	[input_ids, None, input_mask]  # None is the input for 'past'
            __UpperCamelCase				=	model(A_			)

            __UpperCamelCase				=	model(A_			)

            self.parent.assertEqual(result.last_hidden_state.shape,(self.batch_size, self.seq_length, self.hidden_size)			)







       def 						snake_case_					(	self:				Dict,A_:				List[str],A_:				Dict,A_:				Any,A_:				Optional[Any],A_:				Optional[int],*A_:				List[str]			):






            '''simple docstring'''




            __UpperCamelCase				=	TFCTRLLMHeadModel(config=A_			)
            __UpperCamelCase				=	{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
            __UpperCamelCase				=	model(A_			)
            self.parent.assertEqual(result.logits.shape,(self.batch_size, self.seq_length, self.vocab_size)			)







       def 						snake_case_					(	self:				int,A_:				Tuple,A_:				List[str],A_:				Union[str, Any],A_:				Dict,A_:				str,*A_:				List[Any]			):






            '''simple docstring'''




            __UpperCamelCase				=	self.num_labels
            __UpperCamelCase				=	ids_tensor([self.batch_size],self.type_sequence_label_size			)
            __UpperCamelCase				=	{
                'input_ids': input_ids,
                'token_type_ids': token_type_ids,
                'labels': sequence_labels,
            }
            __UpperCamelCase				=	TFCTRLForSequenceClassification(A_			)
            __UpperCamelCase				=	model(A_			)
            self.parent.assertEqual(result.logits.shape,(self.batch_size, self.num_labels)			)







       def 						snake_case_					(	self:				Dict			):






            '''simple docstring'''




            __UpperCamelCase				=	self.prepare_config_and_inputs()

            (
                (
                __UpperCamelCase  
            ),  (
                __UpperCamelCase  
            ),  (
                __UpperCamelCase  
            ),  (
                __UpperCamelCase  
            ),  (
                __UpperCamelCase  
            ),  (
                __UpperCamelCase  
            ),  (
                __UpperCamelCase  
            ),  (
                __UpperCamelCase  
            ),  (
                __UpperCamelCase  
            ),    
            )				=	config_and_inputs

            __UpperCamelCase				=	{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
            return config, inputs_dict



@require_tf
class 					__lowerCamelCase	(_a							,     _a							,     unittest.TestCase		):
       _lowercase    							=      (TFCTRLModel, TFCTRLLMHeadModel, TFCTRLForSequenceClassification) if is_tf_available() else ()
       _lowercase    							=      (TFCTRLLMHeadModel,) if is_tf_available() else ()
       _lowercase    							=      (
           {
               """feature-extraction""": TFCTRLModel,
               """text-classification""": TFCTRLForSequenceClassification,
               """text-generation""": TFCTRLLMHeadModel,
               """zero-shot""": TFCTRLForSequenceClassification,
           }
           if is_tf_available()
           else {}
       )
       _lowercase    							=      False
       _lowercase    							=      False







       def 						snake_case_					(	self:				str,A_:				List[Any],A_:				List[str],A_:				int,A_:				int,A_:				Dict			):






            '''simple docstring'''




            if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests":
                 # Get `tokenizer does not have a padding token` error for both fast/slow tokenizers.
                 # `CTRLConfig` was never used in pipeline tests, either because of a missing checkpoint or because a tiny
                 # config could not be created.
                 return True

            return False







       def 						snake_case_					(	self:				List[str]			):






            '''simple docstring'''




            __UpperCamelCase				=	TFCTRLModelTester(self			)
            __UpperCamelCase				=	ConfigTester(self,config_class=A_,n_embd=37			)







       def 						snake_case_					(	self:				Optional[int]			):






            '''simple docstring'''




            self.config_tester.run_common_tests()







       def 						snake_case_					(	self:				Any			):






            '''simple docstring'''




            __UpperCamelCase				=	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_ctrl_model(*A_			)







       def 						snake_case_					(	self:				int			):






            '''simple docstring'''




            __UpperCamelCase				=	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_ctrl_lm_head(*A_			)







       def 						snake_case_					(	self:				str			):






            '''simple docstring'''




            __UpperCamelCase				=	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_ctrl_for_sequence_classification(*A_			)







       def 						snake_case_					(	self:				List[str]			):






            '''simple docstring'''




            __UpperCamelCase,  __UpperCamelCase				=	self.model_tester.prepare_config_and_inputs_for_common()
            __UpperCamelCase				=	[TFCTRLLMHeadModel]
            __UpperCamelCase				=	[TFCTRLForSequenceClassification]

            for model_class in self.all_model_classes:
                 __UpperCamelCase				=	model_class(A_			)
                 model.build()  # may be needed for the get_bias() call below
                 assert isinstance(model.get_input_embeddings(),tf.keras.layers.Layer			)

                 if model_class in list_lm_models:
                      __UpperCamelCase				=	model.get_output_embeddings()
                      assert isinstance(A_,tf.keras.layers.Layer			)
                      __UpperCamelCase				=	model.get_bias()
                      assert isinstance(A_,A_			)
                      for k, v in name.items():
                           assert isinstance(A_,tf.Variable			)
                 elif model_class in list_other_models_with_output_ebd:
                      __UpperCamelCase				=	model.get_output_embeddings()
                      assert isinstance(A_,tf.keras.layers.Layer			)
                      __UpperCamelCase				=	model.get_bias()
                      assert name is None
                 else:
                      __UpperCamelCase				=	model.get_output_embeddings()
                      assert x is None
                      __UpperCamelCase				=	model.get_bias()
                      assert name is None







       @slow
       def 						snake_case_					(	self:				List[str]			):






            '''simple docstring'''




            for model_name in TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 __UpperCamelCase				=	TFCTRLModel.from_pretrained(A_			)
                 self.assertIsNotNone(A_			)



@require_tf
class 					__lowerCamelCase	(unittest.TestCase		):







       @slow
       def 						snake_case_					(	self:				Dict			):






            '''simple docstring'''




            __UpperCamelCase				=	TFCTRLLMHeadModel.from_pretrained('ctrl'			)
            __UpperCamelCase				=	tf.convert_to_tensor([[1_1859, 0, 1611, 8]],dtype=tf.intaa			)  # Legal the president is
            __UpperCamelCase				=	[
                1_1859,
                0,
                1611,
                8,
                5,
                150,
                2_6449,
                2,
                19,
                348,
                469,
                3,
                2595,
                48,
                2_0740,
                24_6533,
                24_6533,
                19,
                30,
                5,
            ]  # Legal the president is a good guy and I don't want to lose my job. \n \n I have a

            __UpperCamelCase				=	model.generate(A_,do_sample=A_			)
            self.assertListEqual(output_ids[0].numpy().tolist(),A_			)






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 					__lowerCamelCase	(_a		):







       @staticmethod
       def 						snake_case_					(	A_:				ArgumentParser			):






            '''simple docstring'''




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

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



class 					__lowerCamelCase	:
       _lowercase    							=      """\u001b[1m"""
       _lowercase    							=      """\u001b[31m"""
       _lowercase    							=      """\u001b[90m"""
       _lowercase    							=      """\u001b[0m"""







       @classmethod
       def 						snake_case_					(	cls:				Optional[Any],A_:				Tuple			):






            '''simple docstring'''




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







       @classmethod
       def 						snake_case_					(	cls:				Any,A_:				Union[str, Any]			):






            '''simple docstring'''




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







       @classmethod
       def 						snake_case_					(	cls:				Optional[Any],A_:				Dict			):






            '''simple docstring'''




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






def 						_A						(						_lowercase			,       _lowercase				)			->				str:


     """simple docstring"""


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



class 					__lowerCamelCase	:







       def __init__(	self:				List[Any],A_:				Any			):






            '''simple docstring'''




            __UpperCamelCase				=	args



class 					__lowerCamelCase	(_a		):







       def 						snake_case_					(	self:				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 					__lowerCamelCase	(_a		):







       def 						snake_case_					(	self:				List[str]			):






            '''simple docstring'''




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







       def 						snake_case_					(	self:				List[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 					__lowerCamelCase	(_a		):







       def 						snake_case_					(	self:				int			):






            '''simple docstring'''




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

            __UpperCamelCase,  __UpperCamelCase				=	whoami(A_			)
            __UpperCamelCase				=	self.args.organization if self.args.organization is not None else user
            __UpperCamelCase				=	F'''{namespace}/{self.args.name}'''
            print(F'''You are about to create {ANSI.bold(A_			)}'''			)

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


