
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

_A		     =    logging.get_logger(__name__)




def  lowerCamelCase__ (  a__     :     bool		,					a__     :     bool   )						->		Dict:
       def run_func(a__     :     Tuple   ):
              @wraps(__lowerCAmelCase   )
              def run_in_eager_mode(*a__     :     Tuple		,					**a__     :     Optional[Any]   ):
                     return func(*__lowerCAmelCase		,					**__lowerCAmelCase   )

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

              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  lowerCamelCase__ (  a__     :     int		,					a__     :     int		,					a__     :     int   )						->		Union[str, Any]:
       UpperCamelCase_											=				random.Random()
       UpperCamelCase_											=				[rng.randint(0		,					vocab_size - 1   ) for i in range(batch_size * sequence_length   )]
       return tf.constant(__lowerCAmelCase		,					shape=(batch_size, sequence_length)		,					dtype=tf.intaa   )







class 						lowercase_				(				lowerCamelCase_ ):
 A__  : TensorFlowBenchmarkArguments
 A__  : PretrainedConfig
 A__  : str      					=			"TensorFlow"

 @property
 def lowerCamelCase_ (					self   ):




        """simple docstring"""


        return tf.__version__

 def lowerCamelCase_ (					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(__snake_case   ,		__snake_case   ,		__snake_case   )
        return self._measure_speed(_inference   )

 def lowerCamelCase_ (					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(__snake_case   ,		__snake_case   ,		__snake_case   )
        return self._measure_speed(_train   )

 def lowerCamelCase_ (					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]   ,		__snake_case   )
        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(__snake_case   ,		__snake_case   ,		__snake_case   )
        return self._measure_memory(_inference   )

 def lowerCamelCase_ (					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]   ,		__snake_case   )
        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(__snake_case   ,		__snake_case   ,		__snake_case   )
        return self._measure_memory(_train   )

 def lowerCamelCase_ (					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(__snake_case   ,		"""architectures"""   )
            and isinstance(config.architectures   ,		__snake_case   )
            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(__snake_case   ,		__snake_case   )
                      UpperCamelCase_											=				model_cls(__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:
               UpperCamelCase_											=				TF_MODEL_MAPPING[config.__class__](__snake_case   )

        # encoder-decoder has vocab size saved differently
        UpperCamelCase_											=				config.vocab_size if hasattr(__snake_case   ,		"""vocab_size"""   ) else config.encoder.vocab_size
        UpperCamelCase_											=				random_input_ids(__snake_case   ,		__snake_case   ,		__snake_case   )

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

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

        UpperCamelCase_											=				encoder_decoder_forward if config.is_encoder_decoder else encoder_forward

        return _inference

 def lowerCamelCase_ (					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(__snake_case   ,		"""architectures"""   )
            and isinstance(config.architectures   ,		__snake_case   )
            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(__snake_case   ,		__snake_case   )
                      UpperCamelCase_											=				model_cls(__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:
               UpperCamelCase_											=				TF_MODEL_WITH_LM_HEAD_MAPPING[config.__class__](__snake_case   )

        # encoder-decoder has vocab size saved differently
        UpperCamelCase_											=				config.vocab_size if hasattr(__snake_case   ,		"""vocab_size"""   ) else config.encoder.vocab_size
        UpperCamelCase_											=				random_input_ids(__snake_case   ,		__snake_case   ,		__snake_case   )

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

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

        UpperCamelCase_											=				encoder_decoder_train if config.is_encoder_decoder else encoder_train

        return _train

 def lowerCamelCase_ (					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(__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
                      UpperCamelCase_											=				timeit.repeat(
                          __snake_case   ,		repeat=self.args.repeat   ,		number=1_0   ,		)

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

 def lowerCamelCase_ (					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(__snake_case   )
                                    UpperCamelCase_											=				meminfo.used
                                    UpperCamelCase_											=				Memory(__snake_case   )
                                    # 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(__snake_case   )
                                    UpperCamelCase_											=				Memory(__snake_case   ) if isinstance(__snake_case   ,		__snake_case   ) else memory_bytes
                      if self.args.trace_memory_line_by_line:
                             UpperCamelCase_											=				stop_memory_tracing(__snake_case   )
                             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







import argparse


snake_case							:       int     			=      '''docs/source/_static/js/custom.js'''






def 							__lowercase   ( __lowerCAmelCase							:				Optional[Any]   ):
							with open(__lowerCAmelCase					,    encoding='utf-8'					,    newline='\n'   ) as f:
														a__             =     f.readlines()
							a__             =     0

							# First let's put the right version
							while not lines[index].startswith('const stableVersion ='   ):
														index += 1
							a__             =     F'const stableVersion = "v{version}"\n'

							# Then update the dictionary
							while not lines[index].startswith('const versionMapping = {'   ):
														index += 1

							# We go until the end
							while not lines[index].startswith('}'   ):
														index += 1
							# We add the new version at the end
							lines[index - 1] += F'    "v{version}": "v{version}",\n'

							with open(__lowerCAmelCase					,    'w'					,    encoding='utf-8'					,    newline='\n'   ) as f:
														f.writelines(__lowerCAmelCase   )


if __name__ == "__main__":
						snake_case							:       Optional[Any]     			=      argparse.ArgumentParser()
						parser.add_argument('''--version''', help='''Release version.''')
						snake_case							:       Optional[int]     			=      parser.parse_args()
						update_custom_js(args.version)




