




'''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


_SCREAMING_SNAKE_CASE							:       str						=			logging.get_logger(__name__)




@dataclass
class 			_snake_case		(     lowercase_							):
   lowerCAmelCase_					:				List[str]							=   [
       "no_inference",
       "no_cuda",
       "no_tpu",
       "no_speed",
       "no_memory",
       "no_env_print",
       "no_multi_process",
   ]




   def __init__( self    ,							**a__							)    ->    Tuple:

          '''simple docstring'''




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

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




   @cached_property
   def        lowerCAmelCase__    ( self							)    ->    Tuple["tf.distribute.cluster_resolver.TPUClusterResolver"]:

          '''simple docstring'''




          requires_backends(self    ,							["tf"]							)
          snake_case_      =				None
          if self.tpu:
                 try:
                        if self.tpu_name:
                               snake_case_      =				tf.distribute.cluster_resolver.TPUClusterResolver(self.tpu_name							)
                        else:
                               snake_case_      =				tf.distribute.cluster_resolver.TPUClusterResolver()
                 except ValueError:
                        snake_case_      =				None
          return tpu




   @cached_property
   def        lowerCAmelCase__    ( self							)    ->    Tuple["tf.distribute.Strategy", "tf.distribute.cluster_resolver.TPUClusterResolver"]:

          '''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							)

                 snake_case_      =				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"							)
                        snake_case_      =				tf.distribute.OneDeviceStrategy(device=F'/gpu:{self.device_idx}'							)
                 else:
                        tf.config.set_visible_devices([]    ,							"GPU"							)  # disable GPU
                        snake_case_      =				tf.distribute.OneDeviceStrategy(device=F'/cpu:{self.device_idx}'							)

          return strategy




   @property
   def        lowerCAmelCase__    ( self							)    ->    bool:

          '''simple docstring'''




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




   @property
   def        lowerCAmelCase__    ( self							)    ->    "tf.distribute.Strategy":

          '''simple docstring'''




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




   @property
   def        lowerCAmelCase__    ( self							)    ->    List[str]:

          '''simple docstring'''




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




   @property
   def        lowerCAmelCase__    ( self							)    ->    int:

          '''simple docstring'''




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




   @property
   def        lowerCAmelCase__    ( self							)    ->    bool:

          '''simple docstring'''




          return self.n_gpu > 0










'''simple docstring'''





import logging
import os

from .state import PartialState




class 			_snake_case		(     logging.LoggerAdapter							):




			@staticmethod
			def        lowerCAmelCase__    ( a__							)    ->    Optional[Any]:

										'''simple docstring'''




										snake_case_      =				PartialState()
										return not main_process_only or (main_process_only and state.is_main_process)




			def        lowerCAmelCase__    ( self    ,							a__    ,							a__    ,							*a__    ,							**a__							)    ->    List[Any]:

										'''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."							)
										snake_case_      =				kwargs.pop("main_process_only"    ,							a__							)
										snake_case_      =				kwargs.pop("in_order"    ,							a__							)

										if self.isEnabledFor(a__							):
																	if self._should_log(a__							):
																								snake_case_ ,				snake_case_      =				self.process(a__    ,							a__							)
																								self.logger.log(a__    ,							a__    ,							*a__    ,							**a__							)

																	elif in_order:
																								snake_case_      =				PartialState()
																								for i in range(state.num_processes							):
																															if i == state.process_index:
																																						snake_case_ ,				snake_case_      =				self.process(a__    ,							a__							)
																																						self.logger.log(a__    ,							a__    ,							*a__    ,							**a__							)
																															state.wait_for_everyone()


def 					UpperCamelCase_(     snake_case							:	str							,    snake_case							:	str = None					):

							'''simple docstring'''






							if log_level is None:
														snake_case_      =				os.environ.get("ACCELERATE_LOG_LEVEL"							,    snake_case					)
							snake_case_      =				logging.getLogger(snake_case					)
							if log_level is not None:
														logger.setLevel(log_level.upper()					)
														logger.root.setLevel(log_level.upper()					)
							return MultiProcessAdapter(snake_case							,    {}					)




