

"""simple docstring"""






from dataclasses import dataclass, field
from typing import Tuple

from ..utils import cached_property, is_tf_available, logging, requires_backends
from .benchmark_args_utils import BenchmarkArguments


if is_tf_available():
 import tensorflow as tf


_lowerCAmelCase						=		logging.get_logger(__name__)







@dataclass
class 	__UpperCamelCase    (    a__						):
  _UpperCAmelCase          =		[
      "no_inference",
      "no_cuda",
      "no_tpu",
      "no_speed",
      "no_memory",
      "no_env_print",
      "no_multi_process",
  ]

  def __init__(		self    ,**_A      ):
      '''simple docstring'''

      for deprecated_arg in self.deprecated_args:
          if deprecated_arg in kwargs:
              _lowerCAmelCase       :   Tuple  =    deprecated_arg[3:]
              _lowerCAmelCase       :   Tuple  =    not kwargs.pop(__A      )
              logger.warning(
                  F"""{deprecated_arg} is depreciated. Please use --no-{positive_arg} or"""
                  F""" {positive_arg}={kwargs[positive_arg]}"""      )
      _lowerCAmelCase       :   Dict  =    kwargs.pop('tpu_name'    ,self.tpu_name      )
      _lowerCAmelCase       :   List[Any]  =    kwargs.pop('device_idx'    ,self.device_idx      )
      _lowerCAmelCase       :   Optional[int]  =    kwargs.pop('eager_mode'    ,self.eager_mode      )
      _lowerCAmelCase       :   Optional[Any]  =    kwargs.pop('use_xla'    ,self.use_xla      )
      super().__init__(**__A      )

  _UpperCAmelCase          =		field(
      default=a__							,							metadata={"help": "Name of TPU"}							,							)
  _UpperCAmelCase          =		field(
      default=0							,							metadata={"help": "CPU / GPU device index. Defaults to 0."}							,							)
  _UpperCAmelCase          =		field(default=a__							,							metadata={"help": "Benchmark models in eager model."}						)
  _UpperCAmelCase          =		field(
      default=a__							,							metadata={
          "help": "Benchmark models using XLA JIT compilation. Note that `eager_model` has to be set to `False`."
      }							,							)

  @cached_property
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      requires_backends(self    ,['tf']      )
      _lowerCAmelCase       :   Any  =    None
      if self.tpu:
          try:
              if self.tpu_name:
                  _lowerCAmelCase       :   Tuple  =    tf.distribute.cluster_resolver.TPUClusterResolver(self.tpu_name      )
              else:
                  _lowerCAmelCase       :   Optional[int]  =    tf.distribute.cluster_resolver.TPUClusterResolver()
          except ValueError:
              _lowerCAmelCase       :   Tuple  =    None
      return tpu

  @cached_property
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      requires_backends(self    ,['tf']      )
      if self.is_tpu:
          tf.config.experimental_connect_to_cluster(self._setup_tpu      )
          tf.tpu.experimental.initialize_tpu_system(self._setup_tpu      )

          _lowerCAmelCase       :   int  =    tf.distribute.TPUStrategy(self._setup_tpu      )
      else:
          # currently no multi gpu is allowed
          if self.is_gpu:
              # TODO: Currently only single GPU is supported
              tf.config.set_visible_devices(self.gpu_list[self.device_idx]    ,'GPU'      )
              _lowerCAmelCase       :   Tuple  =    tf.distribute.OneDeviceStrategy(device=F"""/gpu:{self.device_idx}"""      )
          else:
              tf.config.set_visible_devices([]    ,'GPU'      )  # disable GPU
              _lowerCAmelCase       :   Optional[int]  =    tf.distribute.OneDeviceStrategy(device=F"""/cpu:{self.device_idx}"""      )

      return strategy

  @property
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      requires_backends(self    ,['tf']      )
      return self._setup_tpu is not None

  @property
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      requires_backends(self    ,['tf']      )
      return self._setup_strategy

  @property
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      requires_backends(self    ,['tf']      )
      return tf.config.list_physical_devices('GPU'      )

  @property
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      requires_backends(self    ,['tf']      )
      if self.cuda:
          return len(self.gpu_list      )
      return 0







  @property
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      return self.n_gpu > 0








"""simple docstring"""






import logging
import os

from .state import PartialState







class 	__UpperCamelCase    (    logging.LoggerAdapter						):

  @staticmethod
  def __lowerCamelCase		(		_A      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Optional[Any]  =    PartialState()
      return not main_process_only or (main_process_only and state.is_main_process)







  def __lowerCamelCase		(		self    ,_A    ,_A    ,*_A    ,**_A      ):
      '''simple docstring'''

      if PartialState._shared_state == {}:
          raise RuntimeError(
              'You must initialize the accelerate state by calling either `PartialState()` or `Accelerator()` before using the logging utility.'      )
      _lowerCAmelCase       :   Tuple  =    kwargs.pop('main_process_only'    ,_A      )
      _lowerCAmelCase       :   Any  =    kwargs.pop('in_order'    ,_A      )

      if self.isEnabledFor(_A      ):
          if self._should_log(_A      ):
              _lowerCAmelCase,					_lowerCAmelCase       :   Optional[int]  =    self.process(_A    ,_A      )
              self.logger.log(_A    ,_A    ,*_A    ,**_A      )

          elif in_order:
              _lowerCAmelCase       :   str  =    PartialState()
              for i in range(state.num_processes      ):
                  if i == state.process_index:
                      _lowerCAmelCase,					_lowerCAmelCase       :   Optional[int]  =    self.process(_A    ,_A      )
                      self.logger.log(_A    ,_A    ,*_A    ,**_A      )
                  state.wait_for_everyone()





def 		lowerCamelCase__		(					_lowerCamelCase ,   _lowerCamelCase = None   ):

    '''simple docstring'''



    if log_level is None:
        _lowerCAmelCase       :   Union[str, Any]  =    os.environ.get('ACCELERATE_LOG_LEVEL' ,   _lowerCamelCase   )
    _lowerCAmelCase       :   int  =    logging.getLogger(_lowerCamelCase   )
    if log_level is not None:
        logger.setLevel(log_level.upper()   )
        logger.root.setLevel(log_level.upper()   )
    return MultiProcessAdapter(_lowerCamelCase ,   {}   )





