

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

snake_case_        =			logging.get_logger(__name__)

def      snake_case__      (   SCREAMING_SNAKE_CASE_		:   bool     ,					SCREAMING_SNAKE_CASE_		:   bool      ):



     '''simple docstring'''





     def run_func(SCREAMING_SNAKE_CASE_		:   Optional[Any]      ):
          @wraps(SCREAMING_SNAKE_CASE_      )
          def run_in_eager_mode(*SCREAMING_SNAKE_CASE_		:   List[str]     ,					**SCREAMING_SNAKE_CASE_		:   Tuple      ):
               return func(*SCREAMING_SNAKE_CASE_     ,					**SCREAMING_SNAKE_CASE_      )

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

          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      snake_case__      (   SCREAMING_SNAKE_CASE_		:   int     ,					SCREAMING_SNAKE_CASE_		:   int     ,					SCREAMING_SNAKE_CASE_		:   int      ):



     '''simple docstring'''





     lowercase__   :       List[str]				=	random.Random()
     lowercase__   :       int				=	[rng.randint(0     ,					vocab_size - 1      ) for i in range(batch_size * sequence_length      )]
     return tf.constant(SCREAMING_SNAKE_CASE_     ,					shape=(batch_size, sequence_length)     ,					dtype=tf.intaa      )


class 				SCREAMING_SNAKE_CASE__ (__snake_case					):
    __lowerCamelCase						:	TensorFlowBenchmarkArguments
    __lowerCamelCase						:	PretrainedConfig
    __lowerCamelCase						:	str														=					"TensorFlow"





    @property
    def 				snake_case_    (				self):
         return tf.__version__





    def 				snake_case_    (				self						,       a						,       a						,       a):
         # initialize GPU on separate process
         lowercase__   :       int				=	self.args.strategy
         if strategy is None:
              raise ValueError('A device strategy has to be initialized before using TensorFlow.')
         lowercase__   :       int				=	self._prepare_inference_func(a						,       a						,       a)
         return self._measure_speed(_inference)





    def 				snake_case_    (				self						,       a						,       a						,       a):
         lowercase__   :       List[Any]				=	self.args.strategy
         if strategy is None:
              raise ValueError('A device strategy has to be initialized before using TensorFlow.')
         lowercase__   :       List[str]				=	self._prepare_train_func(a						,       a						,       a)
         return self._measure_speed(_train)





    def 				snake_case_    (				self						,       a						,       a						,       a):
         # initialize GPU on separate process
         if self.args.is_gpu:
              tf.config.experimental.set_memory_growth(self.args.gpu_list[self.args.device_idx]						,       a)
         lowercase__   :       Dict				=	self.args.strategy
         if strategy is None:
              raise ValueError('A device strategy has to be initialized before using TensorFlow.')
         lowercase__   :       Any				=	self._prepare_inference_func(a						,       a						,       a)
         return self._measure_memory(_inference)





    def 				snake_case_    (				self						,       a						,       a						,       a):
         if self.args.is_gpu:
              tf.config.experimental.set_memory_growth(self.args.gpu_list[self.args.device_idx]						,       a)
         lowercase__   :       Union[str, Any]				=	self.args.strategy
         if strategy is None:
              raise ValueError('A device strategy has to be initialized before using TensorFlow.')

         lowercase__   :       Optional[int]				=	self._prepare_train_func(a						,       a						,       a)
         return self._measure_memory(_train)





    def 				snake_case_    (				self						,       a						,       a						,       a):
         lowercase__   :       Optional[int]				=	self.config_dict[model_name]

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

         lowercase__   :       Union[str, Any]				=	(
             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:
                   lowercase__   :       Any				=	'TF' + config.architectures[0]  # prepend 'TF' for tensorflow model
                   lowercase__   :       Tuple				=	__import__('transformers'						,       fromlist=[model_class])
                   lowercase__   :       List[Any]				=	getattr(a						,       a)
                   lowercase__   :       Tuple				=	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:
              lowercase__   :       Union[str, Any]				=	TF_MODEL_MAPPING[config.__class__](a)

         # encoder-decoder has vocab size saved differently
         lowercase__   :       Optional[int]				=	config.vocab_size if hasattr(a						,       'vocab_size') else config.encoder.vocab_size
         lowercase__   :       List[Any]				=	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)

         lowercase__   :       Optional[int]				=	encoder_decoder_forward if config.is_encoder_decoder else encoder_forward

         return _inference





    def 				snake_case_    (				self						,       a						,       a						,       a):
         lowercase__   :       Union[str, Any]				=	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.')

         lowercase__   :       Optional[Any]				=	(
             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:
                   lowercase__   :       Optional[int]				=	'TF' + config.architectures[0]  # prepend 'TF' for tensorflow model
                   lowercase__   :       int				=	__import__('transformers'						,       fromlist=[model_class])
                   lowercase__   :       int				=	getattr(a						,       a)
                   lowercase__   :       Union[str, Any]				=	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:
              lowercase__   :       Tuple				=	TF_MODEL_WITH_LM_HEAD_MAPPING[config.__class__](a)

         # encoder-decoder has vocab size saved differently
         lowercase__   :       List[Any]				=	config.vocab_size if hasattr(a						,       'vocab_size') else config.encoder.vocab_size
         lowercase__   :       Optional[Any]				=	random_input_ids(a						,       a						,       a)

         @run_with_tf_optimizations(self.args.eager_mode						,       self.args.use_xla)
         def encoder_decoder_train():
              lowercase__   :       int				=	model(a						,       decoder_input_ids=a						,       labels=a						,       training=a)[0]
              lowercase__   :       List[str]				=	tf.gradients(a						,       model.trainable_variables)
              return gradients

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

         lowercase__   :       Union[str, Any]				=	encoder_decoder_train if config.is_encoder_decoder else encoder_train

         return _train





    def 				snake_case_    (				self						,       a):
         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
                   lowercase__   :       List[str]				=	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 				snake_case_    (				self						,       a):
         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.')
                        lowercase__   :       int				=	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.')
                             lowercase__   :       Optional[int]				=	'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()
                             lowercase__   :       Union[str, Any]				=	nvml.nvmlDeviceGetHandleByIndex(self.args.device_idx)
                             lowercase__   :       Union[str, Any]				=	nvml.nvmlDeviceGetMemoryInfo(a)
                             lowercase__   :       Optional[Any]				=	meminfo.used
                             lowercase__   :       str				=	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.')
                             lowercase__   :       Dict				=	None
                        else:
                             lowercase__   :       Dict				=	measure_peak_memory_cpu(a)
                             lowercase__   :       int				=	Memory(a) if isinstance(a						,       a) else memory_bytes
                   if self.args.trace_memory_line_by_line:
                        lowercase__   :       List[str]				=	stop_memory_tracing(a)
                        if memory is None:
                             lowercase__   :       Union[str, Any]				=	summary.total
                   else:
                        lowercase__   :       Optional[int]				=	None

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




def      snake_case__      (   SCREAMING_SNAKE_CASE_		:   int      ):



     '''simple docstring'''





     return 1 if digit in (0, 1) else (digit * factorial(digit - 1      ))

def      snake_case__      (   SCREAMING_SNAKE_CASE_		:   int      ):



     '''simple docstring'''





     lowercase__   :       List[str]				=	0
     lowercase__   :       Optional[int]				=	number
     while duplicate > 0:
          lowercase__				,			lowercase__   :       Tuple				=	divmod(SCREAMING_SNAKE_CASE_     ,					10      )
          fact_sum += factorial(SCREAMING_SNAKE_CASE_      )
     return fact_sum == number


if __name__ == "__main__":
       print('''Program to check whether a number is a Krisnamurthy Number or not.''')
       snake_case_        =			int(input('''Enter number: ''').strip())
       print(
           F'''{number} is {'' if krishnamurthy(number) else 'not '}a Krishnamurthy Number.'''
       )

