



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    _SCREAMING_SNAKE_CASE						(UpperCamelCase			):





     @staticmethod
     def 						__snake_case     (							UpperCamelCase			:				ArgumentParser					)->str:
      __SCREAMING_SNAKE_CASE							:     int							=						parser.add_parser("login"  ,	help="Log in using the same credentials as on huggingface.co"					)
      login_parser.set_defaults(func=lambda UpperCamelCase					: LoginCommand(UpperCamelCase					)					)
      __SCREAMING_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 UpperCamelCase					: WhoamiCommand(UpperCamelCase					)					)
      __SCREAMING_SNAKE_CASE							:     int							=						parser.add_parser("logout"  ,	help="Log out"					)
      logout_parser.set_defaults(func=lambda UpperCamelCase					: LogoutCommand(UpperCamelCase					)					)

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






class    _SCREAMING_SNAKE_CASE						:
     lowerCAmelCase       =      """\u001b[1m"""
     lowerCAmelCase       =      """\u001b[31m"""
     lowerCAmelCase       =      """\u001b[90m"""
     lowerCAmelCase       =      """\u001b[0m"""





     @classmethod
     def 						__snake_case     (							cls			:				List[str]  ,	UpperCamelCase			:				str					)->Dict:
      return F"""{cls._bold}{s}{cls._reset}"""





     @classmethod
     def 						__snake_case     (							cls			:				Union[str, Any]  ,	UpperCamelCase			:				Union[str, Any]					)->List[str]:
      return F"""{cls._bold}{cls._red}{s}{cls._reset}"""






     @classmethod
     def 						__snake_case     (							cls			:				Optional[Any]  ,	UpperCamelCase			:				str					)->Optional[int]:
      return F"""{cls._gray}{s}{cls._reset}"""






def 						_lowerCAmelCase    (					__lowerCamelCase :  List[List[Union[str, int]]]		,						__lowerCamelCase :  List[str]  ):



 """simple docstring"""





 __SCREAMING_SNAKE_CASE							:     List[Any]							=						[max(len(str(__lowerCamelCase  )  ) for x in col  ) for col in zip(*__lowerCamelCase		,						__lowerCamelCase  )]
 __SCREAMING_SNAKE_CASE							:     int							=						("{{:{}}} " * len(__lowerCamelCase  )).format(*__lowerCamelCase  )
 __SCREAMING_SNAKE_CASE							:     Tuple							=						[]
 lines.append(row_format.format(*__lowerCamelCase  )  )
 lines.append(row_format.format(*["-" * w for w in col_widths]  )  )
 for row in rows:
  lines.append(row_format.format(*__lowerCamelCase  )  )
 return "\n".join(__lowerCamelCase  )

class    _SCREAMING_SNAKE_CASE						:





     def __init__(							self			:				int  ,	UpperCamelCase			:				int					)->Tuple:
      __SCREAMING_SNAKE_CASE							:     Union[str, Any]							=						args






class    _SCREAMING_SNAKE_CASE						(UpperCamelCase			):





     def 						__snake_case     (							self			:				Optional[int]					)->Optional[Any]:
      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    _SCREAMING_SNAKE_CASE						(UpperCamelCase			):





     def 						__snake_case     (							self			:				Optional[int]					)->Dict:
      print(
          ANSI.red(
              "WARNING! `transformers-cli whoami` is deprecated and will be removed in v5. Please use "
              "`huggingface-cli whoami` instead."					)					)
      __SCREAMING_SNAKE_CASE							:     Dict							=						HfFolder.get_token()
      if token is None:
       print("Not logged in"					)
       exit()
      try:
       __SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE							:     Optional[int]							=						whoami(UpperCamelCase					)
       print(UpperCamelCase					)
       if orgs:
        print(ANSI.bold("orgs: "					)  ,	",".join(UpperCamelCase					)					)
      except HTTPError as e:
       print(UpperCamelCase					)
       print(ANSI.red(e.response.text					)					)
       exit(1					)






class    _SCREAMING_SNAKE_CASE						(UpperCamelCase			):





     def 						__snake_case     (							self			:				Any					)->Optional[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    _SCREAMING_SNAKE_CASE						(UpperCamelCase			):





     def 						__snake_case     (							self			:				Dict					)->int:
      print(
          ANSI.red(
              "WARNING! Managing repositories through transformers-cli is deprecated. "
              "Please use `huggingface-cli` instead."					)					)
      __SCREAMING_SNAKE_CASE							:     Union[str, Any]							=						HfFolder.get_token()
      if token is None:
       print("Not logged in"					)
       exit(1					)
      try:
       __SCREAMING_SNAKE_CASE							:     Tuple							=						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							:     Tuple							=						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							:     Optional[int]							=						whoami(UpperCamelCase					)
      __SCREAMING_SNAKE_CASE							:     int							=						self.args.organization if self.args.organization is not None else user
      __SCREAMING_SNAKE_CASE							:     List[Any]							=						F"""{namespace}/{self.args.name}"""
      print(F"""You are about to create {ANSI.bold(UpperCamelCase					)}"""					)

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













"""simple docstring"""


import unittest

from transformers import SpeechaTextaConfig
from transformers.testing_utils import is_torch_available, require_torch, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
   import torch

   from transformers.models.speech_to_text_a.modeling_speech_to_text_a import (
       SpeechaTextaDecoder,
       SpeechaTextaForCausalLM,
   )



@require_torch
class   lowercase_					:

       def __init__(      self ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE=99 ,       __SCREAMING_SNAKE_CASE=13 ,       __SCREAMING_SNAKE_CASE=16 ,       __SCREAMING_SNAKE_CASE=7 ,       __SCREAMING_SNAKE_CASE=True ,       __SCREAMING_SNAKE_CASE=True ,       __SCREAMING_SNAKE_CASE=True ,       __SCREAMING_SNAKE_CASE=False ,       __SCREAMING_SNAKE_CASE=True ,       __SCREAMING_SNAKE_CASE=2 ,       __SCREAMING_SNAKE_CASE=32 ,       __SCREAMING_SNAKE_CASE=4 ,       __SCREAMING_SNAKE_CASE=4 ,       __SCREAMING_SNAKE_CASE=30 ,       __SCREAMING_SNAKE_CASE=0 ,       __SCREAMING_SNAKE_CASE=1 ,       __SCREAMING_SNAKE_CASE=2 ,       __SCREAMING_SNAKE_CASE=None ,       ):






        '''simple docstring'''

        snake_case__     				=					parent
        snake_case__     				=					batch_size
        snake_case__     				=					decoder_seq_length
        # For common tests
        snake_case__     				=					self.decoder_seq_length
        snake_case__     				=					is_training
        snake_case__     				=					use_attention_mask
        snake_case__     				=					use_labels

        snake_case__     				=					vocab_size
        snake_case__     				=					d_model
        snake_case__     				=					d_model
        snake_case__     				=					decoder_layers
        snake_case__     				=					decoder_layers
        snake_case__     				=					decoder_ffn_dim
        snake_case__     				=					decoder_attention_heads
        snake_case__     				=					decoder_attention_heads
        snake_case__     				=					eos_token_id
        snake_case__     				=					bos_token_id
        snake_case__     				=					pad_token_id
        snake_case__     				=					decoder_start_token_id
        snake_case__     				=					use_cache
        snake_case__     				=					max_position_embeddings

        snake_case__     				=					None
        snake_case__     				=					decoder_seq_length
        snake_case__     				=					2
        snake_case__     				=					1

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        snake_case__     				=					ids_tensor([self.batch_size, self.decoder_seq_length] ,       self.vocab_size  )

        snake_case__     				=					None
        if self.use_attention_mask:
         snake_case__     				=					ids_tensor([self.batch_size, self.decoder_seq_length] ,       vocab_size=2  )

        snake_case__     				=					None
        if self.use_labels:
         snake_case__     				=					ids_tensor([self.batch_size, self.decoder_seq_length] ,       self.vocab_size  )

        snake_case__     				=					SpeechaTextaConfig(
            vocab_size=self.vocab_size ,       d_model=self.d_model ,       decoder_layers=self.decoder_layers ,       decoder_ffn_dim=self.decoder_ffn_dim ,       decoder_attention_heads=self.decoder_attention_heads ,       eos_token_id=self.eos_token_id ,       bos_token_id=self.bos_token_id ,       use_cache=self.use_cache ,       pad_token_id=self.pad_token_id ,       decoder_start_token_id=self.decoder_start_token_id ,       max_position_embeddings=self.max_position_embeddings ,       )

        return (
            config,
            input_ids,
            attention_mask,
            lm_labels,
        )

       def 		_SCREAMING_SNAKE_CASE(      self ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       ):






        '''simple docstring'''

        snake_case__     				=					True
        snake_case__     				=					SpeechaTextaDecoder(config=__SCREAMING_SNAKE_CASE  ).to(__SCREAMING_SNAKE_CASE  ).eval()
        snake_case__     				=					input_ids[:2]

        input_ids[input_ids == 0] += 1
        # first forward pass
        snake_case__     				=					model(__SCREAMING_SNAKE_CASE ,       use_cache=__SCREAMING_SNAKE_CASE  )
        snake_case__     				=					model(__SCREAMING_SNAKE_CASE  )
        snake_case__     				=					model(__SCREAMING_SNAKE_CASE ,       use_cache=__SCREAMING_SNAKE_CASE  )

        self.parent.assertTrue(len(__SCREAMING_SNAKE_CASE  ) == len(__SCREAMING_SNAKE_CASE  )  )
        self.parent.assertTrue(len(__SCREAMING_SNAKE_CASE  ) == len(__SCREAMING_SNAKE_CASE  ) + 1  )

        snake_case__     				=					outputs["past_key_values"]

        # create hypothetical next token and extent to next_input_ids
        snake_case__     				=					ids_tensor((2, 1) ,       config.vocab_size - 1  ) + 1

        # append to next input_ids and
        snake_case__     				=					torch.cat([input_ids, next_tokens] ,       dim=-1  )

        print(__SCREAMING_SNAKE_CASE  )

        snake_case__     				=					model(__SCREAMING_SNAKE_CASE  )["last_hidden_state"]
        snake_case__     				=					model(__SCREAMING_SNAKE_CASE ,       past_key_values=__SCREAMING_SNAKE_CASE  )["last_hidden_state"]

        # select random slice
        snake_case__     				=					ids_tensor((1,) ,       output_from_past.shape[-1]  ).item()
        snake_case__     				=					output_from_no_past[:, next_input_ids.shape[-1] - 1, random_slice_idx].detach()
        snake_case__     				=					output_from_past[:, 0, random_slice_idx].detach()

        # test that outputs are equal for slice
        assert torch.allclose(__SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       atol=1e-3  )

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        snake_case__     				=					self.prepare_config_and_inputs()
        (
            (
            snake_case__
        )				, (
            snake_case__
        )				, (
            snake_case__
        )				, (
            snake_case__
        )				, 
        )     				=					config_and_inputs

        snake_case__     				=					{
            "input_ids": input_ids,
            "attention_mask": attention_mask,
        }
        return config, inputs_dict



@require_torch
class   lowercase_					(  __lowerCAmelCase					,__lowerCAmelCase					,__lowerCAmelCase					,unittest.TestCase				):
       snake_case__					:				Tuple									=  (SpeechaTextaDecoder, SpeechaTextaForCausalLM) if is_torch_available() else ()
       snake_case__					:				Optional[Any]									=  (SpeechaTextaForCausalLM,) if is_torch_available() else ()
       snake_case__					:				List[Any]									=  {"""text-generation""": SpeechaTextaForCausalLM} if is_torch_available() else {}
       snake_case__					:				Dict									=  True
       snake_case__					:				Dict									=  False

       def 		_SCREAMING_SNAKE_CASE(      self ,       ):






        '''simple docstring'''

        snake_case__     				=					SpeechaTextaStandaloneDecoderModelTester(self ,       is_training=__SCREAMING_SNAKE_CASE  )
        snake_case__     				=					ConfigTester(self ,       config_class=__SCREAMING_SNAKE_CASE  )

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        pass

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        pass

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        pass

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        self.config_tester.run_common_tests()

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        snake_case__     				=					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_decoder_model_past(*__SCREAMING_SNAKE_CASE  )

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        return

