




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 				lowerCAmelCase_	(     snake_case_,snake_case_     ):
      def run_func(snake_case_     ):
            @wraps(snake_case_     )
            def run_in_eager_mode(*snake_case_,**snake_case_     ):
                  return func(*snake_case_,**snake_case_     )

            @wraps(snake_case_     )
            @tf.function(experimental_compile=snake_case_     )
            def run_in_graph_mode(*snake_case_,**snake_case_     ):
                  return func(*snake_case_,**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 				lowerCAmelCase_	(     snake_case_,snake_case_,snake_case_     ):
      _A							:     List[Any]			=						random.Random()
      _A							:     Optional[int]			=						[rng.randint(0,vocab_size - 1     ) for i in range(batch_size * sequence_length     )]
      return tf.constant(snake_case_,shape=(batch_size, sequence_length),dtype=tf.intaa     )







class 						lowercase							(   UpperCamelCase__		):
     _a							 =						42
     _a							 =						42
     _a							 =						"TensorFlow"

     @property
     def 					a__	(  self				)						->							Any:
           return tf.__version__

     def 					a__	(  self		,     _a		,     _a		,     _a				)						->							float:
           # initialize GPU on separate process
           _A							:     List[Any]			=						self.args.strategy
           if strategy is None:
                 raise ValueError("""A device strategy has to be initialized before using TensorFlow."""				)
           _A							:     Optional[Any]			=						self._prepare_inference_func(_a		,     _a		,     _a				)
           return self._measure_speed(_inference				)

     def 					a__	(  self		,     _a		,     _a		,     _a				)						->							float:
           _A							:     Optional[int]			=						self.args.strategy
           if strategy is None:
                 raise ValueError("""A device strategy has to be initialized before using TensorFlow."""				)
           _A							:     Dict			=						self._prepare_train_func(_a		,     _a		,     _a				)
           return self._measure_speed(_train				)

     def 					a__	(  self		,     _a		,     _a		,     _a				)						->							[Memory, Optional[MemorySummary]]:
           # 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				)
           _A							:     Dict			=						self.args.strategy
           if strategy is None:
                 raise ValueError("""A device strategy has to be initialized before using TensorFlow."""				)
           _A							:     Dict			=						self._prepare_inference_func(_a		,     _a		,     _a				)
           return self._measure_memory(_inference				)

     def 					a__	(  self		,     _a		,     _a		,     _a				)						->							[Memory, Optional[MemorySummary]]:
           if self.args.is_gpu:
                 tf.config.experimental.set_memory_growth(self.args.gpu_list[self.args.device_idx]		,     _a				)
           _A							:     str			=						self.args.strategy
           if strategy is None:
                 raise ValueError("""A device strategy has to be initialized before using TensorFlow."""				)

           _A							:     str			=						self._prepare_train_func(_a		,     _a		,     _a				)
           return self._measure_memory(_train				)

     def 					a__	(  self		,     _a		,     _a		,     _a				)						->							Callable[[], None]:
           _A							:     Optional[Any]			=						self.config_dict[model_name]

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

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

           # encoder-decoder has vocab size saved differently
           _A							:     Any			=						config.vocab_size if hasattr(_a		,     """vocab_size"""				) else config.encoder.vocab_size
           _A							:     Dict			=						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				)

           _A							:     str			=						encoder_decoder_forward if config.is_encoder_decoder else encoder_forward

           return _inference

     def 					a__	(  self		,     _a		,     _a		,     _a				)						->							Callable[[], None]:
           _A							:     str			=						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."""				)

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

           # encoder-decoder has vocab size saved differently
           _A							:     str			=						config.vocab_size if hasattr(_a		,     """vocab_size"""				) else config.encoder.vocab_size
           _A							:     Optional[int]			=						random_input_ids(_a		,     _a		,     _a				)

           @run_with_tf_optimizations(self.args.eager_mode		,     self.args.use_xla				)
           def encoder_decoder_train():
                 _A							:     str			=						model(_a		,     decoder_input_ids=_a		,     labels=_a		,     training=_a				)[0]
                 _A							:     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():
                 _A							:     str			=						model(_a		,     labels=_a		,     training=_a				)[0]
                 _A							:     Tuple			=						tf.gradients(_a		,     model.trainable_variables				)
                 return gradients

           _A							:     List[str]			=						encoder_decoder_train if config.is_encoder_decoder else encoder_train

           return _train

     def 					a__	(  self		,     _a				)						->							float:
           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
                       _A							:     Union[str, Any]			=						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 					a__	(  self		,     _a				)						->							[Memory, MemorySummary]:
           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."""				)
                             _A							:     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."""				)
                                   _A							:     List[str]			=						"""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()
                                   _A							:     str			=						nvml.nvmlDeviceGetHandleByIndex(self.args.device_idx				)
                                   _A							:     Optional[int]			=						nvml.nvmlDeviceGetMemoryInfo(_a				)
                                   _A							:     int			=						meminfo.used
                                   _A							:     Tuple			=						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."""				)
                                   _A							:     Optional[Any]			=						None
                             else:
                                   _A							:     Tuple			=						measure_peak_memory_cpu(_a				)
                                   _A							:     int			=						Memory(_a				) if isinstance(_a		,     _a				) else memory_bytes
                       if self.args.trace_memory_line_by_line:
                             _A							:     Optional[int]			=						stop_memory_tracing(_a				)
                             if memory is None:
                                   _A							:     Tuple			=						summary.total
                       else:
                             _A							:     Optional[Any]			=						None

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







import multiprocessing
from typing import TYPE_CHECKING, Optional, Union

from .. import Dataset, Features, config
from ..formatting import query_table
from ..packaged_modules.sql.sql import Sql
from ..utils import logging
from .abc import AbstractDatasetInputStream


if TYPE_CHECKING:
  import sqlitea

  import sqlalchemy







class 						lowercase							(   UpperCamelCase__		):

     def __init__(  self		,     _a		,     _a		,     _a = None		,     _a = None		,     _a = False		,     **_a		,     )						->							int:
           super().__init__(features=_a		,     cache_dir=_a		,     keep_in_memory=_a		,     **_a				)
           _A							:     Optional[int]			=						Sql(
               cache_dir=_a		,     features=_a		,     sql=_a		,     con=_a		,     **_a		,     )



     def 					a__	(  self				)						->							Optional[Any]:
           _A							:     Tuple			=						None
           _A							:     int			=						None
           _A							:     Tuple			=						None
           _A							:     Union[str, Any]			=						None

           self.builder.download_and_prepare(
               download_config=_a		,     download_mode=_a		,     verification_mode=_a		,     base_path=_a		,     )

           # Build dataset for splits
           _A							:     int			=						self.builder.as_dataset(
               split="""train"""		,     verification_mode=_a		,     in_memory=self.keep_in_memory				)
           return dataset







class 						lowercase							:

     def __init__(  self		,     _a		,     _a		,     _a		,     _a = None		,     _a = None		,     **_a		,     )						->							Union[str, Any]:
           if num_proc is not None and num_proc <= 0:
                 raise ValueError(F'''num_proc {num_proc} must be an integer > 0.'''				)

           _A							:     Dict			=						dataset
           _A							:     int			=						name
           _A							:     Union[str, Any]			=						con
           _A							:     str			=						batch_size if batch_size else config.DEFAULT_MAX_BATCH_SIZE
           _A							:     str			=						num_proc
           _A							:     Optional[Any]			=						to_sql_kwargs

     def 					a__	(  self				)						->							int:
           _A							:     Any			=						self.to_sql_kwargs.pop("""sql"""		,     _a				)
           _A							:     List[str]			=						self.to_sql_kwargs.pop("""con"""		,     _a				)
           _A							:     int			=						self.to_sql_kwargs.pop("""index"""		,     _a				)

           _A							:     List[str]			=						self._write(index=_a		,     **self.to_sql_kwargs				)
           return written

     def 					a__	(  self		,     _a				)						->							Optional[int]:
           _A			,   _A			,   _A							:     List[str]			=						args
           _A							:     int			=						{**to_sql_kwargs, """if_exists""": """append"""} if offset > 0 else to_sql_kwargs
           _A							:     str			=						query_table(
               table=self.dataset.data		,     key=slice(_a		,     offset + self.batch_size				)		,     indices=self.dataset._indices		,     )
           _A							:     Tuple			=						batch.to_pandas()
           _A							:     Union[str, Any]			=						df.to_sql(self.name		,     self.con		,     index=_a		,     **_a				)
           return num_rows or len(_a				)



     def 					a__	(  self		,     _a		,     **_a				)						->							int:
           _A							:     Any			=						0

           if self.num_proc is None or self.num_proc == 1:
                 for offset in logging.tqdm(
                     range(0		,     len(self.dataset				)		,     self.batch_size				)		,     unit="""ba"""		,     disable=not logging.is_progress_bar_enabled()		,     desc="""Creating SQL from Arrow format"""		,     ):
                       written += self._batch_sql((offset, index, to_sql_kwargs)				)
           else:
                 _A			,   _A							:     Tuple			=						len(self.dataset				), self.batch_size
                 with multiprocessing.Pool(self.num_proc				) as pool:
                       for num_rows in logging.tqdm(
                           pool.imap(
                               self._batch_sql		,     [(offset, index, to_sql_kwargs) for offset in range(0		,     _a		,     _a				)]		,     )		,     total=(num_rows // batch_size) + 1 if num_rows % batch_size else num_rows // batch_size		,     unit="""ba"""		,     disable=not logging.is_progress_bar_enabled()		,     desc="""Creating SQL from Arrow format"""		,     ):
                             written += num_rows

           return written

