



'''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	:		Any				=   logging.get_logger(__name__)






@dataclass
class 					UpperCAmelCase__	(		UpperCamelCase__ ):
					a      :     int        =							[
					    """no_inference""",
					    """no_cuda""",
					    """no_tpu""",
					    """no_speed""",
					    """no_memory""",
					    """no_env_print""",
					    """no_multi_process""",
					]



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

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



					@cached_property
					def        UpperCAmelCase_ (    self     )     ->			Tuple["tf.distribute.cluster_resolver.TPUClusterResolver"]:
						requires_backends(self			,				["tf"]     )
						__lowerCAmelCase												=  None
						if self.tpu:
							try:
								if self.tpu_name:
									__lowerCAmelCase												=  tf.distribute.cluster_resolver.TPUClusterResolver(self.tpu_name     )
								else:
									__lowerCAmelCase												=  tf.distribute.cluster_resolver.TPUClusterResolver()
							except ValueError:
								__lowerCAmelCase												=  None
						return tpu



					@cached_property
					def        UpperCAmelCase_ (    self     )     ->			Tuple["tf.distribute.Strategy", "tf.distribute.cluster_resolver.TPUClusterResolver"]:
						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												=  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												=  tf.distribute.OneDeviceStrategy(device=F'''/gpu:{self.device_idx}'''     )
							else:
								tf.config.set_visible_devices([]			,				"GPU"     )  # disable GPU
								__lowerCAmelCase												=  tf.distribute.OneDeviceStrategy(device=F'''/cpu:{self.device_idx}'''     )

						return strategy



					@property
					def        UpperCAmelCase_ (    self     )     ->			bool:
						requires_backends(self			,				["tf"]     )
						return self._setup_tpu is not None



					@property
					def        UpperCAmelCase_ (    self     )     ->			"tf.distribute.Strategy":
						requires_backends(self			,				["tf"]     )
						return self._setup_strategy



					@property
					def        UpperCAmelCase_ (    self     )     ->			Union[str, Any]:
						requires_backends(self			,				["tf"]     )
						return tf.config.list_physical_devices("GPU"     )



					@property
					def        UpperCAmelCase_ (    self     )     ->			int:
						requires_backends(self			,				["tf"]     )
						if self.cuda:
							return len(self.gpu_list     )
						return 0



					@property
					def        UpperCAmelCase_ (    self     )     ->			bool:
						return self.n_gpu > 0




'''simple docstring'''



import requests
from bsa import BeautifulSoup



def   __lowerCAmelCase					(							lowerCamelCase   :						str = "https://www.worldometers.info/coronavirus"					):






	'''simple docstring'''




	__lowerCAmelCase												=  BeautifulSoup(requests.get(lowerCamelCase					).text				,		"html.parser"					)
	__lowerCAmelCase												=  soup.findAll("h1"					)
	__lowerCAmelCase												=  soup.findAll("div"				,		{"class": "maincounter-number"}					)
	keys += soup.findAll("span"				,		{"class": "panel-title"}					)
	values += soup.findAll("div"				,		{"class": "number-table-main"}					)
	return {key.text.strip(): value.text.strip() for key, value in zip(lowerCamelCase				,		lowerCamelCase					)}


if __name__ == "__main__":
	print('''\033[1m''' + '''COVID-19 Status of the World''' + '''\033[0m\n''')
	for key, value in world_covidaa_stats().items():
		print(f'{key}\n{value}\n')