
'''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     a (					__magic_name__     ):




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

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




class     a :
				_snake_case		     =			'''\u001b[1m'''
				_snake_case		     =			'''\u001b[31m'''
				_snake_case		     =			'''\u001b[90m'''
				_snake_case		     =			'''\u001b[0m'''




				@classmethod
				def 						__snake_case				(				cls						:					List[Any],     SCREAMING_SNAKE_CASE_						:					Tuple   ):
										return F"""{cls._bold}{s}{cls._reset}"""




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




				@classmethod
				def 						__snake_case				(				cls						:					Tuple,     SCREAMING_SNAKE_CASE_						:					int   ):
										return F"""{cls._gray}{s}{cls._reset}"""




def   A			(							A_				:       List[List[Union[str, int]]]     ,				A_				:       List[str]							):
						snake_case							:  Optional[Any]			=     [max(len(str(_UpperCAmelCase							)							) for x in col							) for col in zip(*_UpperCAmelCase     ,				_UpperCAmelCase							)]
						snake_case							:  Optional[int]			=     ('{{:{}}} ' * len(_UpperCAmelCase							)).format(*_UpperCAmelCase							)
						snake_case							:  Union[str, Any]			=     []
						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     a :




				def __init__(				self						:					Any,     SCREAMING_SNAKE_CASE_						:					int   ):
										snake_case							:  Union[str, Any]			=     args




class     a (					__magic_name__     ):




				def 						__snake_case				(				self						:					List[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     a (					__magic_name__     ):




				def 						__snake_case				(				self						:					List[str]   ):
										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							:  str			=     whoami(SCREAMING_SNAKE_CASE_   )
																print(SCREAMING_SNAKE_CASE_   )
																if orgs:
																						print(ANSI.bold('''orgs: '''   ),     ''','''.join(SCREAMING_SNAKE_CASE_   )   )
										except HTTPError as e:
																print(SCREAMING_SNAKE_CASE_   )
																print(ANSI.red(e.response.text   )   )
																exit(1   )




class     a (					__magic_name__     ):




				def 						__snake_case				(				self						:					int   ):
										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 (					__magic_name__     ):




				def 						__snake_case				(				self						:					Optional[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							:  List[str]			=     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							:  Union[str, 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							:  Tuple			=     whoami(SCREAMING_SNAKE_CASE_   )
										snake_case							:  str			=     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(SCREAMING_SNAKE_CASE_   )}"""   )

										if not self.args.yes:
																snake_case							:  Optional[int]			=     input('''Proceed? [Y/n] '''   ).lower()
																if not (choice == "" or choice == "y" or choice == "yes"):
																						print('''Abort'''   )
																						exit()
										try:
																snake_case							:  List[str]			=     create_repo(SCREAMING_SNAKE_CASE_,     name=self.args.name,     organization=self.args.organization   )
										except HTTPError as e:
																print(SCREAMING_SNAKE_CASE_   )
																print(ANSI.red(e.response.text   )   )
																exit(1   )
										print('''\nYour repo now lives at:'''   )
										print(F"""  {ANSI.bold(SCREAMING_SNAKE_CASE_   )}"""   )
										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 timeit
from typing import Callable, Optional

from ..configuration_utils import PretrainedConfig
from ..models.auto.modeling_auto import MODEL_MAPPING, MODEL_WITH_LM_HEAD_MAPPING
from ..utils import is_pyanvml_available, is_torch_available, logging
from .benchmark_utils import (
    Benchmark,
    Memory,
    MemorySummary,
    measure_peak_memory_cpu,
    start_memory_tracing,
    stop_memory_tracing,
)


if is_torch_available():
    import torch

    from .benchmark_args import PyTorchBenchmarkArguments


if is_pyanvml_available():
    import pyanvml.pyanvml as nvml


A_				     =							logging.get_logger(__name__)


class 		UpperCamelCase__     (       a							):
      '''simple docstring'''






      _snake_case           =				42
      _snake_case           =				42
      _snake_case           =				"PyTorch"




      @property
      def 	snake_case  (     self )				->  Dict:
        return torch.__version__




      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )				->  float:
        __lowerCAmelCase		:    Any			     =  self._prepare_inference_func(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )
        return self._measure_speed(_inference )




      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )				->  [Memory, Optional[MemorySummary]]:
        __lowerCAmelCase		:    Dict			     =  self._prepare_inference_func(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )
        return self._measure_memory(_inference )




      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )				->  float:
        __lowerCAmelCase		:    Optional[Any]			     =  self._prepare_train_func(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )
        return self._measure_speed(_train )




      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )				->  [Memory, Optional[MemorySummary]]:
        __lowerCAmelCase		:    Optional[int]			     =  self._prepare_train_func(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )
        return self._measure_memory(_train )




      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )				->  Callable[[], None]:
        __lowerCAmelCase		:    str			     =  self.config_dict[model_name]

        if self.args.torchscript:
          __lowerCAmelCase		:    Tuple			     =  True

        __lowerCAmelCase		:    Union[str, Any]			     =  (
            hasattr(SCREAMING_SNAKE_CASE     , 'architectures' )
            and isinstance(config.architectures     , SCREAMING_SNAKE_CASE )
            and len(config.architectures ) > 0
        )
        if not self.args.only_pretrain_model and has_model_class_in_config:
          try:
            __lowerCAmelCase		:    Dict			     =  config.architectures[0]
            __lowerCAmelCase		:    List[str]			     =  __import__('transformers'     , fromlist=[model_class] )
            __lowerCAmelCase		:    Tuple			     =  getattr(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )
            __lowerCAmelCase		:    Dict			     =  model_cls(SCREAMING_SNAKE_CASE )
          except ImportError:
            raise ImportError(
                F"""{model_class} does not exist. If you just want to test the pretrained model, you might want to"""
                ' set `--only_pretrain_model` or `args.only_pretrain_model=True`.' )
        else:
          __lowerCAmelCase		:    List[Any]			     =  MODEL_MAPPING[config.__class__](SCREAMING_SNAKE_CASE )

        model.eval()
        model.to(self.args.device )

        # encoder-decoder has vocab size saved differently
        __lowerCAmelCase		:    List[str]			     =  config.vocab_size if hasattr(SCREAMING_SNAKE_CASE     , 'vocab_size' ) else config.encoder.vocab_size
        __lowerCAmelCase		:    Optional[Any]			     =  torch.randint(SCREAMING_SNAKE_CASE     , (batch_size, sequence_length)     , dtype=torch.long     , device=self.args.device )

        if self.args.fpaa:
          logger.info('Running training in Mixed Precision...' )
          if not self.args.is_gpu:
            raise ValueError('Mixed precision is possible only for GPU.' )
          # amp seems to have memory leaks so that memory usage
          # is measured using .half() for now https://github.com/NVIDIA/apex/issues/439
          model.half()

        if self.args.torchscript:
          with torch.no_grad():
            __lowerCAmelCase		:    List[Any]			     =  torch.jit.trace(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )
        else:
          __lowerCAmelCase		:    str			     =  model

        def encoder_decoder_forward():
          with torch.no_grad():
            __lowerCAmelCase		:    str			     =  inference_model(SCREAMING_SNAKE_CASE     , decoder_input_ids=SCREAMING_SNAKE_CASE )
          return outputs

        def encoder_forward():
          with torch.no_grad():
            __lowerCAmelCase		:    str			     =  inference_model(SCREAMING_SNAKE_CASE )
          return outputs

        __lowerCAmelCase		:    Optional[Any]			     =  encoder_decoder_forward if config.is_encoder_decoder else encoder_forward
        return _forward




      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )				->  Callable[[], None]:
        __lowerCAmelCase		:    int			     =  self.config_dict[model_name]

        __lowerCAmelCase		:    Optional[int]			     =  (
            hasattr(SCREAMING_SNAKE_CASE     , 'architectures' )
            and isinstance(config.architectures     , SCREAMING_SNAKE_CASE )
            and len(config.architectures ) > 0
        )
        if not self.args.only_pretrain_model and has_model_class_in_config:
          try:
            __lowerCAmelCase		:    List[Any]			     =  config.architectures[0]
            __lowerCAmelCase		:    List[str]			     =  __import__('transformers'     , fromlist=[model_class] )
            __lowerCAmelCase		:    Tuple			     =  getattr(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )
            __lowerCAmelCase		:    Any			     =  model_cls(SCREAMING_SNAKE_CASE )
          except ImportError:
            raise ImportError(
                F"""{model_class} does not exist. If you just want to test the pretrained model, you might want to"""
                ' set `--only_pretrain_model` or `args.only_pretrain_model=True`.' )
        else:
          __lowerCAmelCase		:    List[str]			     =  MODEL_WITH_LM_HEAD_MAPPING[config.__class__](SCREAMING_SNAKE_CASE )

        if self.args.torchscript:
          raise NotImplementedError('Training for torchscript is currently not implemented' )
        else:
          __lowerCAmelCase		:    int			     =  model

        model.train()
        model.to(self.args.device )

        # encoder-decoder has vocab size saved differently
        __lowerCAmelCase		:    Tuple			     =  config.vocab_size if hasattr(SCREAMING_SNAKE_CASE     , 'vocab_size' ) else config.encoder.vocab_size
        __lowerCAmelCase		:    Optional[int]			     =  torch.randint(SCREAMING_SNAKE_CASE     , (batch_size, sequence_length)     , dtype=torch.long     , device=self.args.device )

        if self.args.fpaa:
          logger.info('Running training in Mixed Precision...' )
          if not self.args.is_gpu:
            raise ValueError('Mixed precision is possible only for GPU.' )

          # amp seems to have memory leaks so that memory usage
          # is measured using .half() for now https://github.com/NVIDIA/apex/issues/439
          model.half()

        def compute_loss_and_backprob_encoder():
          __lowerCAmelCase		:    List[str]			     =  train_model(SCREAMING_SNAKE_CASE     , labels=SCREAMING_SNAKE_CASE )[0]
          loss.backward()
          return loss

        def compute_loss_and_backprob_encoder_decoder():
          __lowerCAmelCase		:    List[Any]			     =  train_model(SCREAMING_SNAKE_CASE     , decoder_input_ids=SCREAMING_SNAKE_CASE     , labels=SCREAMING_SNAKE_CASE )[0]
          loss.backward()
          return loss

        __lowerCAmelCase		:    Dict			     =  (
            compute_loss_and_backprob_encoder_decoder
            if config.is_encoder_decoder
            else compute_loss_and_backprob_encoder
        )
        return _train




      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE )				->  float:
        try:
          if self.args.is_tpu or self.args.torchscript:
            # run additional 10 times to stabilize compilation for tpu and torchscript
            logger.info('Do inference on TPU or torchscript. Running model 5 times to stabilize compilation' )
            timeit.repeat(
                SCREAMING_SNAKE_CASE     , repeat=1     , number=5     , )

          # as written in https://docs.python.org/2/library/timeit.html#timeit.Timer.repeat, min should be taken rather than the average
          __lowerCAmelCase		:    Tuple			     =  timeit.repeat(
              SCREAMING_SNAKE_CASE     , repeat=self.args.repeat     , number=10     , )

          if self.args.is_tpu and self.args.torch_xla_tpu_print_metrics:
            import torch_xla.debug.metrics as met

            self.print_fn(met.metrics_report() )

          return min(SCREAMING_SNAKE_CASE ) / 1_0.0
        except RuntimeError as e:
          self.print_fn(F"""Doesn't fit on GPU. {e}""" )
          return "N/A"







      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE )				->  [Memory, MemorySummary]:
        try:
          if self.args.trace_memory_line_by_line:
            __lowerCAmelCase		:    Tuple			     =  start_memory_tracing('transformers' )

          if self.args.is_tpu:
            # tpu
            raise NotImplementedError(
                'Memory Benchmarking is currently not implemented for TPU. Please disable memory benchmarking with'
                ' `--no-memory` or `args.memory=False`' )
          elif self.args.is_gpu:
            if not is_pyanvml_available():
              logger.warning(
                  'py3nvml not installed, we won\'t log GPU memory usage. '
                  'Install py3nvml (pip install py3nvml) to log information about GPU.' )
              __lowerCAmelCase		:    Union[str, Any]			     =  'N/A'
            else:
              logger.info(
                  'Measuring total GPU usage on GPU device. Make sure to not have additional processes running'
                  ' on the same GPU.' )
              # init nvml
              nvml.nvmlInit()
              func()
              __lowerCAmelCase		:    int			     =  nvml.nvmlDeviceGetHandleByIndex(self.args.device_idx )
              __lowerCAmelCase		:    List[str]			     =  nvml.nvmlDeviceGetMemoryInfo(SCREAMING_SNAKE_CASE )
              __lowerCAmelCase		:    Tuple			     =  meminfo.used
              __lowerCAmelCase		:    Dict			     =  Memory(SCREAMING_SNAKE_CASE )
              # shutdown nvml
              nvml.nvmlShutdown()
          else:
            # cpu
            __lowerCAmelCase		:    Tuple			     =  measure_peak_memory_cpu(SCREAMING_SNAKE_CASE )
            __lowerCAmelCase		:    str			     =  Memory(SCREAMING_SNAKE_CASE ) if isinstance(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE ) else memory_bytes

          if self.args.trace_memory_line_by_line:
            __lowerCAmelCase		:    int			     =  stop_memory_tracing(SCREAMING_SNAKE_CASE )
          else:
            __lowerCAmelCase		:    Any			     =  None

          return memory, summary
        except RuntimeError as e:
          self.print_fn(F"""Doesn't fit on GPU. {e}""" )
          return "N/A", None





