


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


__UpperCAmelCase					       =							datasets.utils.logging.get_logger(__name__)




@dataclass
class 	a__       (							datasets.BuilderConfig						):





							'''simple docstring'''






							lowercase__    :     Optional[datasets.Features]					=   None
							lowercase__    :     str					=   "utf-8"
							lowercase__    :     Optional[str]					=   None
							lowercase__    :     Optional[str]					=   None
							lowercase__    :     bool					=   True  # deprecated
							lowercase__    :     Optional[int]					=   None  # deprecated
							lowercase__    :     int					=   1_0 << 2_0  # 10MB
							lowercase__    :     Optional[bool]					=   None




class 	a__       (							datasets.ArrowBasedBuilder						):





							'''simple docstring'''






							lowercase__    :     Union[str, Any]					=   JsonConfig







							def 						__SCREAMING_SNAKE_CASE							(	self     ) ->							int:
														if self.config.block_size is not None:
																					logger.warning('''The JSON loader parameter `block_size` is deprecated. Please use `chunksize` instead'''     )
																					lowerCAmelCase__      =			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 						__SCREAMING_SNAKE_CASE							(	self      ,					lowerCamelCase_     ) ->							Union[str, Any]:
														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}"""     )
														lowerCAmelCase__      =			dl_manager.download_and_extract(self.config.data_files     )
														if isinstance(lowerCamelCase_      ,					(str, list, tuple)     ):
																					lowerCAmelCase__      =			data_files
																					if isinstance(lowerCamelCase_      ,					lowerCamelCase_     ):
																												lowerCAmelCase__      =			[files]
																					lowerCAmelCase__      =			[dl_manager.iter_files(lowerCamelCase_     ) for file in files]
																					return [datasets.SplitGenerator(name=datasets.Split.TRAIN      ,					gen_kwargs={'''files''': files}     )]
														lowerCAmelCase__      =			[]
														for split_name, files in data_files.items():
																					if isinstance(lowerCamelCase_      ,					lowerCamelCase_     ):
																												lowerCAmelCase__      =			[files]
																					lowerCAmelCase__      =			[dl_manager.iter_files(lowerCamelCase_     ) for file in files]
																					splits.append(datasets.SplitGenerator(name=lowerCamelCase_      ,					gen_kwargs={'''files''': files}     )     )
														return splits







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







							def 						__SCREAMING_SNAKE_CASE							(	self      ,					lowerCamelCase_     ) ->							str:
														for file_idx, file in enumerate(itertools.chain.from_iterable(lowerCamelCase_     )     ):
																					# 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(lowerCamelCase_      ,					encoding=self.config.encoding      ,					errors=self.config.encoding_errors     ) as f:
																																			lowerCAmelCase__      =			json.load(lowerCamelCase_     )

																												# We keep only the field we are interested in
																												lowerCAmelCase__      =			dataset[self.config.field]

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

																					# If the file has one json object per line
																					else:
																												with open(lowerCamelCase_      ,					'''rb'''     ) as f:
																																			lowerCAmelCase__      =			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
																																			lowerCAmelCase__      =			max(self.config.chunksize // 32      ,					16 << 10     )
																																			lowerCAmelCase__      =			(
																																			    self.config.encoding_errors if self.config.encoding_errors is not None else '''strict'''
																																			)
																																			while True:
																																										lowerCAmelCase__      =			f.read(self.config.chunksize     )
																																										if not batch:
																																																	break
																																										# Finish current line
																																										try:
																																																	batch += f.readline()
																																										except (AttributeError, io.UnsupportedOperation):
																																																	batch += readline(lowerCamelCase_     )
																																										# PyArrow only accepts utf-8 encoded bytes
																																										if self.config.encoding != "utf-8":
																																																	lowerCAmelCase__      =			batch.decode(self.config.encoding      ,					errors=lowerCamelCase_     ).encode('''utf-8'''     )
																																										try:
																																																	while True:
																																																								try:
																																																															lowerCAmelCase__      =			paj.read_json(
																																																															    io.BytesIO(lowerCamelCase_     )      ,					read_options=paj.ReadOptions(block_size=lowerCamelCase_     )     )
																																																															break
																																																								except (pa.ArrowInvalid, pa.ArrowNotImplementedError) as e:
																																																															if (
																																																															    isinstance(lowerCamelCase_      ,					pa.ArrowInvalid     )
																																																															    and "straddling" not in str(lowerCamelCase_     )
																																																															    or block_size > len(lowerCamelCase_     )
																																																															):
																																																																						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(lowerCamelCase_     )} 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(
																																																								    lowerCamelCase_      ,					encoding=self.config.encoding      ,					errors=self.config.encoding_errors     ) as f:
																																																															lowerCAmelCase__      =			json.load(lowerCamelCase_     )
																																																	except json.JSONDecodeError:
																																																								logger.error(F"""Failed to read file '{file}' with error {type(lowerCamelCase_     )}: {e}"""     )
																																																								raise e
																																																	# If possible, parse the file as a list of json objects and exit the loop
																																																	if isinstance(lowerCamelCase_      ,					lowerCamelCase_     ):  # list is the only sequence type supported in JSON
																																																								try:
																																																															lowerCAmelCase__      =			set().union(*[row.keys() for row in dataset]     )
																																																															lowerCAmelCase__      =			{col: [row.get(lowerCamelCase_     ) for row in dataset] for col in keys}
																																																															lowerCAmelCase__      =			pa.Table.from_pydict(lowerCamelCase_     )
																																																								except (pa.ArrowInvalid, AttributeError) as e:
																																																															logger.error(F"""Failed to read file '{file}' with error {type(lowerCamelCase_     )}: {e}"""     )
																																																															raise ValueError(F"""Not able to read records in the JSON file at {file}."""     ) from None
																																																								yield file_idx, self._cast_table(lowerCamelCase_     )
																																																								break
																																																	else:
																																																								logger.error(F"""Failed to read file '{file}' with error {type(lowerCamelCase_     )}: {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(lowerCamelCase_     )
																																										batch_idx += 1



'''simple docstring'''






from math import pi, sqrt, tan


def       _snake_case     (  A )		->					float:
							if side_length < 0:
														raise ValueError('''surface_area_cube() only accepts non-negative values''' )
							return 6 * side_length**2


def       _snake_case     (  A				,					A				,					A )		->					float:
							if length < 0 or breadth < 0 or height < 0:
														raise ValueError('''surface_area_cuboid() only accepts non-negative values''' )
							return 2 * ((length * breadth) + (breadth * height) + (length * height))


def       _snake_case     (  A )		->					float:
							if radius < 0:
														raise ValueError('''surface_area_sphere() only accepts non-negative values''' )
							return 4 * pi * radius**2


def       _snake_case     (  A )		->					float:
							if radius < 0:
														raise ValueError('''surface_area_hemisphere() only accepts non-negative values''' )
							return 3 * pi * radius**2


def       _snake_case     (  A				,					A )		->					float:
							if radius < 0 or height < 0:
														raise ValueError('''surface_area_cone() only accepts non-negative values''' )
							return pi * radius * (radius + (height**2 + radius**2) ** 0.5)


def       _snake_case     (  A				,					A				,					A )		->					float:
							if radius_a < 0 or radius_a < 0 or height < 0:
														raise ValueError(
														    '''surface_area_conical_frustum() only accepts non-negative values''' )
							lowerCAmelCase__      =			(height**2 + (radius_a - radius_a) ** 2) ** 0.5
							return pi * ((slant_height * (radius_a + radius_a)) + radius_a**2 + radius_a**2)


def       _snake_case     (  A				,					A )		->					float:
							if radius < 0 or height < 0:
														raise ValueError('''surface_area_cylinder() only accepts non-negative values''' )
							return 2 * pi * radius * (height + radius)


def       _snake_case     (  A				,					A )		->					float:
							if torus_radius < 0 or tube_radius < 0:
														raise ValueError('''surface_area_torus() only accepts non-negative values''' )
							if torus_radius < tube_radius:
														raise ValueError(
														    '''surface_area_torus() does not support spindle or self intersecting tori''' )
							return 4 * pow(A				,					2 ) * torus_radius * tube_radius


def       _snake_case     (  A				,					A )		->					float:
							if length < 0 or width < 0:
														raise ValueError('''area_rectangle() only accepts non-negative values''' )
							return length * width


def       _snake_case     (  A )		->					float:
							if side_length < 0:
														raise ValueError('''area_square() only accepts non-negative values''' )
							return side_length**2


def       _snake_case     (  A				,					A )		->					float:
							if base < 0 or height < 0:
														raise ValueError('''area_triangle() only accepts non-negative values''' )
							return (base * height) / 2


def       _snake_case     (  A				,					A				,					A )		->					float:
							if sidea < 0 or sidea < 0 or sidea < 0:
														raise ValueError('''area_triangle_three_sides() only accepts non-negative values''' )
							elif sidea + sidea < sidea or sidea + sidea < sidea or sidea + sidea < sidea:
														raise ValueError('''Given three sides do not form a triangle''' )
							lowerCAmelCase__      =			(sidea + sidea + sidea) / 2
							lowerCAmelCase__      =			sqrt(
							    semi_perimeter
							    * (semi_perimeter - sidea)
							    * (semi_perimeter - sidea)
							    * (semi_perimeter - sidea) )
							return area


def       _snake_case     (  A				,					A )		->					float:
							if base < 0 or height < 0:
														raise ValueError('''area_parallelogram() only accepts non-negative values''' )
							return base * height


def       _snake_case     (  A				,					A				,					A )		->					float:
							if basea < 0 or basea < 0 or height < 0:
														raise ValueError('''area_trapezium() only accepts non-negative values''' )
							return 1 / 2 * (basea + basea) * height


def       _snake_case     (  A )		->					float:
							if radius < 0:
														raise ValueError('''area_circle() only accepts non-negative values''' )
							return pi * radius**2


def       _snake_case     (  A				,					A )		->					float:
							if radius_x < 0 or radius_y < 0:
														raise ValueError('''area_ellipse() only accepts non-negative values''' )
							return pi * radius_x * radius_y


def       _snake_case     (  A				,					A )		->					float:
							if diagonal_a < 0 or diagonal_a < 0:
														raise ValueError('''area_rhombus() only accepts non-negative values''' )
							return 1 / 2 * diagonal_a * diagonal_a


def       _snake_case     (  A				,					A )		->					float:
							if not isinstance(A				,					A ) or sides < 3:
														raise ValueError(
														    '''area_reg_polygon() only accepts integers greater than or \
equal to three as number of sides''' )
							elif length < 0:
														raise ValueError(
														    '''area_reg_polygon() only accepts non-negative values as \
length of a side''' )
							return (sides * length**2) / (4 * tan(pi / sides ))
							return (sides * length**2) / (4 * tan(pi / sides ))


if __name__ == "__main__":
		import doctest

		doctest.testmod(verbose=True)  # verbose so we can see methods missing tests

		print('''[DEMO] Areas of various geometric shapes: \n''')
		print(f"""Rectangle: {area_rectangle(10, 20) = }""")
		print(f"""Square: {area_square(10) = }""")
		print(f"""Triangle: {area_triangle(10, 10) = }""")
		print(f"""Triangle: {area_triangle_three_sides(5, 12, 13) = }""")
		print(f"""Parallelogram: {area_parallelogram(10, 20) = }""")
		print(f"""Rhombus: {area_rhombus(10, 20) = }""")
		print(f"""Trapezium: {area_trapezium(10, 20, 30) = }""")
		print(f"""Circle: {area_circle(20) = }""")
		print(f"""Ellipse: {area_ellipse(10, 20) = }""")
		print('''\nSurface Areas of various geometric shapes: \n''')
		print(f"""Cube: {surface_area_cube(20) = }""")
		print(f"""Cuboid: {surface_area_cuboid(10, 20, 30) = }""")
		print(f"""Sphere: {surface_area_sphere(20) = }""")
		print(f"""Hemisphere: {surface_area_hemisphere(20) = }""")
		print(f"""Cone: {surface_area_cone(10, 20) = }""")
		print(f"""Conical Frustum: {surface_area_conical_frustum(10, 20, 30) = }""")
		print(f"""Cylinder: {surface_area_cylinder(10, 20) = }""")
		print(f"""Torus: {surface_area_torus(20, 10) = }""")
		print(f"""Equilateral Triangle: {area_reg_polygon(3, 10) = }""")
		print(f"""Square: {area_reg_polygon(4, 10) = }""")
		print(f"""Reqular Pentagon: {area_reg_polygon(5, 10) = }""")