




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


lowercase__     						=						logging.get_logger(__name__)






@dataclass
class lowerCAmelCase__	(     lowercase						):






			'''simple docstring'''



			lowerCamelCase__      =			[
			    """no_inference""",
			    """no_cuda""",
			    """no_tpu""",
			    """no_speed""",
			    """no_memory""",
			    """no_env_print""",
			    """no_multi_process""",
			]
			def __init__(  self  ,      **lowercase  ):
							for deprecated_arg in self.deprecated_args:
											if deprecated_arg in kwargs:
															_lowerCamelCase     :			Any    =    deprecated_arg[3:]
															_lowerCamelCase     :			int    =    not kwargs.pop(lowercase  )
															logger.warning(
															    F'''{deprecated_arg} is depreciated. Please use --no-{positive_arg} or'''
															    F''' {positive_arg}={kwargs[positive_arg]}'''  )
							_lowerCamelCase     :			Any    =    kwargs.pop('tpu_name'  ,      self.tpu_name  )
							_lowerCamelCase     :			Dict    =    kwargs.pop('device_idx'  ,      self.device_idx  )
							_lowerCamelCase     :			int    =    kwargs.pop('eager_mode'  ,      self.eager_mode  )
							_lowerCamelCase     :			List[str]    =    kwargs.pop('use_xla'  ,      self.use_xla  )
							super().__init__(**lowercase  )

			lowerCamelCase__      =			field(
			    default=lowercase,	metadata={"""help""": """Name of TPU"""},	)
			lowerCamelCase__      =			field(
			    default=0,	metadata={"""help""": """CPU / GPU device index. Defaults to 0."""},	)
			lowerCamelCase__      =			field(default=lowercase,	metadata={"""help""": """Benchmark models in eager model."""}						)
			lowerCamelCase__      =			field(
			    default=lowercase,	metadata={
			        """help""": """Benchmark models using XLA JIT compilation. Note that `eager_model` has to be set to `False`."""
			    },	)
			@cached_property
			def 					A_    (  self  ):
							requires_backends(self  ,      ['tf']  )
							_lowerCamelCase     :			int    =    None
							if self.tpu:
											try:
															if self.tpu_name:
																			_lowerCamelCase     :			List[Any]    =    tf.distribute.cluster_resolver.TPUClusterResolver(self.tpu_name  )
															else:
																			_lowerCamelCase     :			str    =    tf.distribute.cluster_resolver.TPUClusterResolver()
											except ValueError:
															_lowerCamelCase     :			List[str]    =    None
							return tpu
			@cached_property
			def 					A_    (  self  ):
							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     :			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     :			Dict    =    tf.distribute.OneDeviceStrategy(device=F'''/gpu:{self.device_idx}'''  )
											else:
															tf.config.set_visible_devices([]  ,      'GPU'  )  # disable GPU
															_lowerCamelCase     :			int    =    tf.distribute.OneDeviceStrategy(device=F'''/cpu:{self.device_idx}'''  )

							return strategy
			@property
			def 					A_    (  self  ):
							requires_backends(self  ,      ['tf']  )
							return self._setup_tpu is not None
			@property
			def 					A_    (  self  ):
							requires_backends(self  ,      ['tf']  )
							return self._setup_strategy
			@property
			def 					A_    (  self  ):
							requires_backends(self  ,      ['tf']  )
							return tf.config.list_physical_devices('GPU'  )
			@property
			def 					A_    (  self  ):
							requires_backends(self  ,      ['tf']  )
							if self.cuda:
											return len(self.gpu_list  )
							return 0






			@property
			def 					A_    (  self  ):
							return self.n_gpu > 0






import pytest
import requests

from datasets.utils.file_utils import http_head

from .utils import OfflineSimulationMode, RequestWouldHangIndefinitelyError, offline



@pytest.mark.integration
def 		A_				(     )						-> List[Any]:
 with offline(OfflineSimulationMode.CONNECTION_TIMES_OUT     ):
  with pytest.raises(_lowerCAmelCase     ):
   requests.request("GET"							,   "https://huggingface.co"     )
  with pytest.raises(requests.exceptions.ConnectTimeout     ):
   requests.request("GET"							,   "https://huggingface.co"							,   timeout=1.0     )



@pytest.mark.integration
def 		A_				(     )						-> Tuple:
 with offline(OfflineSimulationMode.CONNECTION_FAILS     ):
  with pytest.raises(requests.exceptions.ConnectionError     ):
   requests.request("GET"							,   "https://huggingface.co"     )



def 		A_				(     )						-> Optional[int]:
 with offline(OfflineSimulationMode.HF_DATASETS_OFFLINE_SET_TO_1     ):
  with pytest.raises(_lowerCAmelCase     ):
   http_head("https://huggingface.co"     )
