


'''simple docstring'''



import io
import itertools
import json
from dataclasses import dataclass
from typing import Optional

import pyarrow as pa
import pyarrow.json as paj

import datasets
from datasets.table import table_cast
from datasets.utils.file_utils import readline


__lowercase      :		Union[str, Any]			=      datasets.utils.logging.get_logger(__name__)





@dataclass
class 				__UpperCamelCase							(						datasets.BuilderConfig   ):
	A_           =       None
	A_           =       "utf-8"
	A_           =       None
	A_           =       None
	A_           =       True  # deprecated
	A_           =       None  # deprecated
	A_           =       10 << 20  # 10MB
	A_           =       None





class 				__UpperCamelCase							(						datasets.ArrowBasedBuilder   ):
	A_           =       JsonConfig




	def  __UpperCAmelCase				(  self				):

						'''simple docstring'''





						if self.config.block_size is not None:
											logger.warning('The JSON loader parameter `block_size` is deprecated. Please use `chunksize` instead'				)
											__a     :			List[str]          =    self.config.block_size
						if self.config.use_threads is not True:
											logger.warning(
											    'The JSON loader parameter `use_threads` is deprecated and doesn\'t have any effect anymore.'				)
						if self.config.newlines_in_values is not None:
											raise ValueError('The JSON loader parameter `newlines_in_values` is no longer supported'				)
						return datasets.DatasetInfo(features=self.config.features				)




	def  __UpperCAmelCase				(  self		,							__a				):

						'''simple docstring'''





						if not self.config.data_files:
											raise ValueError(f"""At least one data file must be specified, but got data_files={self.config.data_files}"""				)
						__a     :			Optional[Any]          =    dl_manager.download_and_extract(self.config.data_files				)
						if isinstance(a__		,							(str, list, tuple)				):
											__a     :			str          =    data_files
											if isinstance(a__		,							a__				):
																__a     :			Union[str, Any]          =    [files]
											__a     :			List[Any]          =    [dl_manager.iter_files(a__				) for file in files]
											return [datasets.SplitGenerator(name=datasets.Split.TRAIN		,							gen_kwargs={'files': files}				)]
						__a     :			Any          =    []
						for split_name, files in data_files.items():
											if isinstance(a__		,							a__				):
																__a     :			List[Any]          =    [files]
											__a     :			Union[str, Any]          =    [dl_manager.iter_files(a__				) for file in files]
											splits.append(datasets.SplitGenerator(name=a__		,							gen_kwargs={'files': files}				)				)
						return splits




	def  __UpperCAmelCase				(  self		,							__a				):

						'''simple docstring'''





						if self.config.features is not None:
											# adding missing columns
											for column_name in set(self.config.features				) - set(pa_table.column_names				):
																__a     :			str          =    self.config.features.arrow_schema.field(a__				).type
																__a     :			Union[str, Any]          =    pa_table.append_column(a__		,							pa.array([None] * len(a__				)		,							type=a__				)				)
											# more expensive cast to support nested structures with keys in a different order
											# allows str <-> int/float or str to Audio for example
											__a     :			List[Any]          =    table_cast(a__		,							self.config.features.arrow_schema				)
						return pa_table





	def  __UpperCAmelCase				(  self		,							__a				):

						'''simple docstring'''





						for file_idx, file in enumerate(itertools.chain.from_iterable(a__				)				):
											# If the file is one json object and if we need to look at the list of items in one specific field
											if self.config.field is not None:
																with open(a__		,							encoding=self.config.encoding		,							errors=self.config.encoding_errors				) as f:
																					__a     :			Tuple          =    json.load(a__				)

																# We keep only the field we are interested in
																__a     :			Union[str, Any]          =    dataset[self.config.field]

																# We accept two format: a list of dicts or a dict of lists
																if isinstance(a__		,							(list, tuple)				):
																					__a     :			List[Any]          =    set().union(*[row.keys() for row in dataset]				)
																					__a     :			Optional[int]          =    {col: [row.get(a__				) for row in dataset] for col in keys}
																else:
																					__a     :			List[Any]          =    dataset
																__a     :			int          =    pa.Table.from_pydict(a__				)
																yield file_idx, self._cast_table(a__				)

											# If the file has one json object per line
											else:
																with open(a__		,							'rb'				) as f:
																					__a     :			Optional[int]          =    0
																					# Use block_size equal to the chunk size divided by 32 to leverage multithreading
																					# Set a default minimum value of 16kB if the chunk size is really small
																					__a     :			Dict          =    max(self.config.chunksize // 32		,							16 << 10				)
																					__a     :			List[str]          =    (
																					    self.config.encoding_errors if self.config.encoding_errors is not None else 'strict'
																					)
																					while True:
																										__a     :			Union[str, Any]          =    f.read(self.config.chunksize				)
																										if not batch:
																															break
																										# Finish current line
																										try:
																															batch += f.readline()
																										except (AttributeError, io.UnsupportedOperation):
																															batch += readline(a__				)
																										# PyArrow only accepts utf-8 encoded bytes
																										if self.config.encoding != "utf-8":
																															__a     :			Dict          =    batch.decode(self.config.encoding		,							errors=a__				).encode('utf-8'				)
																										try:
																															while True:
																																				try:
																																									__a     :			Dict          =    paj.read_json(
																																									    io.BytesIO(a__				)		,							read_options=paj.ReadOptions(block_size=a__				)				)
																																									break
																																				except (pa.ArrowInvalid, pa.ArrowNotImplementedError) as e:
																																									if (
																																									    isinstance(a__		,							pa.ArrowInvalid				)
																																									    and "straddling" not in str(a__				)
																																									    or block_size > len(a__				)
																																									):
																																														raise
																																									else:
																																														# Increase the block size in case it was too small.
																																														# The block size will be reset for the next file.
																																														logger.debug(
																																														    f"""Batch of {len(a__				)} bytes couldn\'t be parsed with block_size={block_size}. Retrying with block_size={block_size * 2}."""				)
																																														block_size *= 2
																										except pa.ArrowInvalid as e:
																															try:
																																				with open(
																																				    a__		,							encoding=self.config.encoding		,							errors=self.config.encoding_errors				) as f:
																																									__a     :			Tuple          =    json.load(a__				)
																															except json.JSONDecodeError:
																																				logger.error(f"""Failed to read file \'{file}\' with error {type(a__				)}: {e}"""				)
																																				raise e
																															# If possible, parse the file as a list of json objects and exit the loop
																															if isinstance(a__		,							a__				):  # list is the only sequence type supported in JSON
																																				try:
																																									__a     :			int          =    set().union(*[row.keys() for row in dataset]				)
																																									__a     :			Union[str, Any]          =    {col: [row.get(a__				) for row in dataset] for col in keys}
																																									__a     :			Dict          =    pa.Table.from_pydict(a__				)
																																				except (pa.ArrowInvalid, AttributeError) as e:
																																									logger.error(f"""Failed to read file \'{file}\' with error {type(a__				)}: {e}"""				)
																																									raise ValueError(f"""Not able to read records in the JSON file at {file}."""				) from None
																																				yield file_idx, self._cast_table(a__				)
																																				break
																															else:
																																				logger.error(f"""Failed to read file \'{file}\' with error {type(a__				)}: {e}"""				)
																																				raise ValueError(
																																				    f"""Not able to read records in the JSON file at {file}. """
																																				    f"""You should probably indicate the field of the JSON file containing your records. """
																																				    f"""This JSON file contain the following fields: {str(list(dataset.keys()				)				)}. """
																																				    f"""Select the correct one and provide it as `field=\'XXX\'` to the dataset loading method. """				) from None
                        # Uncomment for debugging (will print the Arrow table size and elements)
                        # logger.warning(f"pa_table: {pa_table} num rows: {pa_table.num_rows}")
                        # logger.warning('\n'.join(str(pa_table.slice(i, 1).to_pydict()) for i in range(pa_table.num_rows)))
																										yield (file_idx, batch_idx), self._cast_table(a__				)
																										batch_idx += 1







import requests
from bsa import BeautifulSoup





def 	_lowerCAmelCase					( UpperCamelCase__:  str = "https://www.worldometers.info/coronavirus"    )			-> dict:





	"""simple docstring"""







	A             =					BeautifulSoup(requests.get(UpperCamelCase__    ).text				,       """html.parser"""    )
	A             =					soup.findAll("""h1"""    )
	A             =					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(UpperCamelCase__				,       UpperCamelCase__    )}


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



