
"""simple docstring"""

import random
import timeit
from functools import wraps
from typing import Callable, Optional

from ..configuration_utils import PretrainedConfig
from ..models.auto.modeling_tf_auto import TF_MODEL_MAPPING, TF_MODEL_WITH_LM_HEAD_MAPPING
from ..utils import is_pyanvml_available, is_tf_available, logging
from .benchmark_utils import (
    Benchmark,
    Memory,
    MemorySummary,
    measure_peak_memory_cpu,
    start_memory_tracing,
    stop_memory_tracing,
)


if is_tf_available():
      import tensorflow as tf
      from tensorflow.python.framework.errors_impl import ResourceExhaustedError

      from .benchmark_args_tf import TensorFlowBenchmarkArguments

if is_pyanvml_available():
      import pyanvml.pyanvml as nvml

UpperCamelCase     :    int       =			logging.get_logger(__name__)






def 							A						(    snake_case				:int    , snake_case				:Union[str, Any]		)				->     Dict:
 def run_func(snake_case				:Dict		):
  @wraps(__a		)
  def run_in_eager_mode(*snake_case				:int    , **snake_case				:Optional[Any]		):
   return func(*__a    , **__a		)

  @wraps(__a		)
  @tf.function(experimental_compile=__a		)
  def run_in_graph_mode(*snake_case				:Union[str, Any]    , **snake_case				:Optional[int]		):
   return func(*__a    , **__a		)

  if do_eager_mode is True:
   if use_xla is not False:
    raise ValueError(
        'Cannot run model in XLA, if `args.eager_mode` is set to `True`. Please set `args.eager_mode=False`.'		)
   return run_in_eager_mode
  else:
   return run_in_graph_mode

 return run_func






def 							A						(    snake_case				:str    , snake_case				:int    , snake_case				:str		)				->     List[Any]:
 __UpperCamelCase      =	random.Random()
 __UpperCamelCase      =	[rng.randint(0    , vocab_size - 1		) for i in range(batch_size * sequence_length		)]
 return tf.constant(__a    , shape=(batch_size, sequence_length)    , dtype=tf.intaa		)





class __lowerCAmelCase		(				snake_case_      ):






     """simple docstring"""




     lowercase						       =						42
     lowercase						       =						42
     lowercase						       =						"TensorFlow"





     @property
     def 						UpperCAmelCase (     self				):

      '''simple docstring'''




      return tf.__version__





     def 						UpperCAmelCase (     self     ,					__UpperCAmelCase     ,					__UpperCAmelCase     ,					__UpperCAmelCase				):

      '''simple docstring'''




      __UpperCamelCase      =	self.args.strategy
      if strategy is None:
       raise ValueError('A device strategy has to be initialized before using TensorFlow.'				)
      __UpperCamelCase      =	self._prepare_inference_func(_A     ,					_A     ,					_A				)
      return self._measure_speed(_inference				)





     def 						UpperCAmelCase (     self     ,					__UpperCAmelCase     ,					__UpperCAmelCase     ,					__UpperCAmelCase				):

      '''simple docstring'''




      __UpperCamelCase      =	self.args.strategy
      if strategy is None:
       raise ValueError('A device strategy has to be initialized before using TensorFlow.'				)
      __UpperCamelCase      =	self._prepare_train_func(_A     ,					_A     ,					_A				)
      return self._measure_speed(_train				)





     def 						UpperCAmelCase (     self     ,					__UpperCAmelCase     ,					__UpperCAmelCase     ,					__UpperCAmelCase				):

      '''simple docstring'''




      if self.args.is_gpu:
       tf.config.experimental.set_memory_growth(self.args.gpu_list[self.args.device_idx]     ,					_A				)
      __UpperCamelCase      =	self.args.strategy
      if strategy is None:
       raise ValueError('A device strategy has to be initialized before using TensorFlow.'				)
      __UpperCamelCase      =	self._prepare_inference_func(_A     ,					_A     ,					_A				)
      return self._measure_memory(_inference				)





     def 						UpperCAmelCase (     self     ,					__UpperCAmelCase     ,					__UpperCAmelCase     ,					__UpperCAmelCase				):

      '''simple docstring'''




      if self.args.is_gpu:
       tf.config.experimental.set_memory_growth(self.args.gpu_list[self.args.device_idx]     ,					_A				)
      __UpperCamelCase      =	self.args.strategy
      if strategy is None:
       raise ValueError('A device strategy has to be initialized before using TensorFlow.'				)

      __UpperCamelCase      =	self._prepare_train_func(_A     ,					_A     ,					_A				)
      return self._measure_memory(_train				)





     def 						UpperCAmelCase (     self     ,					__UpperCAmelCase     ,					__UpperCAmelCase     ,					__UpperCAmelCase				):

      '''simple docstring'''




      __UpperCamelCase      =	self.config_dict[model_name]

      if self.args.fpaa:
       raise NotImplementedError('Mixed precision is currently not supported.'				)

      __UpperCamelCase      =	(
          hasattr(_A     ,					'architectures'				)
          and isinstance(config.architectures     ,					_A				)
          and len(config.architectures				) > 0
      )
      if not self.args.only_pretrain_model and has_model_class_in_config:
       try:
        __UpperCamelCase      =	'TF' + config.architectures[0]  # prepend 'TF' for tensorflow model
        __UpperCamelCase      =	__import__('transformers'     ,					fromlist=[model_class]				)
        __UpperCamelCase      =	getattr(_A     ,					_A				)
        __UpperCamelCase      =	model_cls(_A				)
       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:
       __UpperCamelCase      =	TF_MODEL_MAPPING[config.__class__](_A				)

      # encoder-decoder has vocab size saved differently
      __UpperCamelCase      =	config.vocab_size if hasattr(_A     ,					'vocab_size'				) else config.encoder.vocab_size
      __UpperCamelCase      =	random_input_ids(_A     ,					_A     ,					_A				)

      @run_with_tf_optimizations(self.args.eager_mode     ,					self.args.use_xla				)
      def encoder_decoder_forward():
       return model(_A     ,					decoder_input_ids=_A     ,					training=_A				)

      @run_with_tf_optimizations(self.args.eager_mode     ,					self.args.use_xla				)
      def encoder_forward():
       return model(_A     ,					training=_A				)

      __UpperCamelCase      =	encoder_decoder_forward if config.is_encoder_decoder else encoder_forward

      return _inference





     def 						UpperCAmelCase (     self     ,					__UpperCAmelCase     ,					__UpperCAmelCase     ,					__UpperCAmelCase				):

      '''simple docstring'''




      __UpperCamelCase      =	self.config_dict[model_name]

      if self.args.eager_mode is not False:
       raise ValueError('Training cannot be done in eager mode. Please make sure that `args.eager_mode = False`.'				)

      if self.args.fpaa:
       raise NotImplementedError('Mixed precision is currently not supported.'				)

      __UpperCamelCase      =	(
          hasattr(_A     ,					'architectures'				)
          and isinstance(config.architectures     ,					_A				)
          and len(config.architectures				) > 0
      )
      if not self.args.only_pretrain_model and has_model_class_in_config:
       try:
        __UpperCamelCase      =	'TF' + config.architectures[0]  # prepend 'TF' for tensorflow model
        __UpperCamelCase      =	__import__('transformers'     ,					fromlist=[model_class]				)
        __UpperCamelCase      =	getattr(_A     ,					_A				)
        __UpperCamelCase      =	model_cls(_A				)
       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:
       __UpperCamelCase      =	TF_MODEL_WITH_LM_HEAD_MAPPING[config.__class__](_A				)

      # encoder-decoder has vocab size saved differently
      __UpperCamelCase      =	config.vocab_size if hasattr(_A     ,					'vocab_size'				) else config.encoder.vocab_size
      __UpperCamelCase      =	random_input_ids(_A     ,					_A     ,					_A				)

      @run_with_tf_optimizations(self.args.eager_mode     ,					self.args.use_xla				)
      def encoder_decoder_train():
       __UpperCamelCase      =	model(_A     ,					decoder_input_ids=_A     ,					labels=_A     ,					training=_A				)[0]
       __UpperCamelCase      =	tf.gradients(_A     ,					model.trainable_variables				)
       return gradients

      @run_with_tf_optimizations(self.args.eager_mode     ,					self.args.use_xla				)
      def encoder_train():
       __UpperCamelCase      =	model(_A     ,					labels=_A     ,					training=_A				)[0]
       __UpperCamelCase      =	tf.gradients(_A     ,					model.trainable_variables				)
       return gradients

      __UpperCamelCase      =	encoder_decoder_train if config.is_encoder_decoder else encoder_train

      return _train





     def 						UpperCAmelCase (     self     ,					__UpperCAmelCase				):

      '''simple docstring'''




      with self.args.strategy.scope():
       try:
        if self.args.is_tpu or self.args.use_xla:
         # run additional 10 times to stabilize compilation for tpu
         logger.info('Do inference on TPU. Running model 5 times to stabilize compilation'				)
         timeit.repeat(_A     ,					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
        __UpperCamelCase      =	timeit.repeat(
            _A     ,					repeat=self.args.repeat     ,					number=10     ,					)

        return min(_A				) / 10.0
       except ResourceExhaustedError as e:
        self.print_fn(F'Doesn\'t fit on GPU. {e}'				)







     def 						UpperCAmelCase (     self     ,					__UpperCAmelCase				):

      '''simple docstring'''




      logger.info(
          'Note that TensorFlow allocates more memory than '
          'it might need to speed up computation. '
          'The memory reported here corresponds to the memory '
          'reported by `nvidia-smi`, which can vary depending '
          'on total available memory on the GPU that is used.'				)
      with self.args.strategy.scope():
       try:
        if self.args.trace_memory_line_by_line:
         if not self.args.eager_mode:
          raise ValueError(
              '`args.eager_mode` is set to `False`. Make sure to run model in eager mode to measure memory'
              ' consumption line by line.'				)
         __UpperCamelCase      =	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 `args.memory=False`'				)
        elif self.args.is_gpu:
         # 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.'				)
          __UpperCamelCase      =	'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()
          __UpperCamelCase      =	nvml.nvmlDeviceGetHandleByIndex(self.args.device_idx				)
          __UpperCamelCase      =	nvml.nvmlDeviceGetMemoryInfo(_A				)
          __UpperCamelCase      =	meminfo.used
          __UpperCamelCase      =	Memory(_A				)
          # shutdown nvml
          nvml.nvmlShutdown()
        else:
         # cpu
         if self.args.trace_memory_line_by_line:
          logger.info(
              'When enabling line by line tracing, the max peak memory for CPU is inaccurate in'
              ' TensorFlow.'				)
          __UpperCamelCase      =	None
         else:
          __UpperCamelCase      =	measure_peak_memory_cpu(_A				)
          __UpperCamelCase      =	Memory(_A				) if isinstance(_A     ,					_A				) else memory_bytes
        if self.args.trace_memory_line_by_line:
         __UpperCamelCase      =	stop_memory_tracing(_A				)
         if memory is None:
          __UpperCamelCase      =	summary.total
        else:
         __UpperCamelCase      =	None

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





"""simple docstring"""

def 							A						(    snake_case				:int		)				->     bool:
 return sum(i for i in range(1    , number // 2 + 1		) if number % i == 0		) == number


if __name__ == "__main__":
      print("Program to check whether a number is a Perfect number or not...")
      UpperCamelCase     :    Union[str, Any]       =			int(input("Enter number: ").strip())
      print(f'''{number} is {"" if perfect(number) else "not "}a Perfect Number.''')



