



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


__A             =       logging.get_logger(__name__)



@dataclass
class      _SCREAMING_SNAKE_CASE		(			__SCREAMING_SNAKE_CASE					):







 '''simple docstring'''
 lowercase_	=    [
     "no_inference",
     "no_cuda",
     "no_tpu",
     "no_speed",
     "no_memory",
     "no_env_print",
     "no_multi_process",
 ]

 def __init__(self       :     List[str] ,				**UpperCAmelCase_       :     Dict) ->int:



   '''simple docstring'''



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

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

 @cached_property
 def 							SCREAMING_SNAKE_CASE_      (self       :     str) ->Union[str, Any]:



   '''simple docstring'''



   requires_backends(self ,				["tf"])
   lowerCamelCase__:   Union[str, Any]    						=None
   if self.tpu:
     try:
       if self.tpu_name:
         lowerCamelCase__:   Optional[Any]    						=tf.distribute.cluster_resolver.TPUClusterResolver(self.tpu_name)
       else:
         lowerCamelCase__:   Dict    						=tf.distribute.cluster_resolver.TPUClusterResolver()
     except ValueError:
       lowerCamelCase__:   List[str]    						=None
   return tpu

 @cached_property
 def 							SCREAMING_SNAKE_CASE_      (self       :     Tuple) ->Any:



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

   return strategy

 @property
 def 							SCREAMING_SNAKE_CASE_      (self       :     List[Any]) ->Dict:



   '''simple docstring'''



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

 @property
 def 							SCREAMING_SNAKE_CASE_      (self       :     Dict) ->Dict:



   '''simple docstring'''



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

 @property
 def 							SCREAMING_SNAKE_CASE_      (self       :     List[Any]) ->int:



   '''simple docstring'''



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

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



   '''simple docstring'''



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







 @property
 def 							SCREAMING_SNAKE_CASE_      (self       :     Union[str, Any]) ->Union[str, Any]:



   '''simple docstring'''



   return self.n_gpu > 0








from __future__ import annotations





def   lowerCAmelCase_				( __a			,					__a			,					__a			,					)  ->	tuple:







  """simple docstring"""





  if (electron_conc, hole_conc, intrinsic_conc).count(0	) != 1:
    raise ValueError("You cannot supply more or less than 2 values"	)
  elif electron_conc < 0:
    raise ValueError("Electron concentration cannot be negative in a semiconductor"	)
  elif hole_conc < 0:
    raise ValueError("Hole concentration cannot be negative in a semiconductor"	)
  elif intrinsic_conc < 0:
    raise ValueError(
        "Intrinsic concentration cannot be negative in a semiconductor"	)
  elif electron_conc == 0:
    return (
        "electron_conc",
        intrinsic_conc**2 / hole_conc,
    )
  elif hole_conc == 0:
    return (
        "hole_conc",
        intrinsic_conc**2 / electron_conc,
    )
  elif intrinsic_conc == 0:
    return (
        "intrinsic_conc",
        (electron_conc * hole_conc) ** 0.5,
    )
  else:
    return (-1, -1)


if __name__ == "__main__":
     import doctest

     doctest.testmod()

