





import itertools
from dataclasses import dataclass
from typing import List, Optional

import pyarrow as pa
import pyarrow.parquet as pq

import datasets
from datasets.table import table_cast


a__      :     Any         =		datasets.utils.logging.get_logger(__name__)





@dataclass
class UpperCAmelCase_				( datasets.BuilderConfig ):
  __lowerCAmelCase   :						int							=   1_0000
  __lowerCAmelCase   :						Optional[List[str]]							=   None
  __lowerCAmelCase   :						Optional[datasets.Features]							=   None





class UpperCAmelCase_				( datasets.ArrowBasedBuilder ):
  __lowerCAmelCase   :						Optional[Any]							=   ParquetConfig


  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       return datasets.DatasetInfo(features=self.config.features )


  def 						__UpperCAmelCase     (							self ,__snake_case ):



       """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_          =       dl_manager.download_and_extract(self.config.data_files )
       if isinstance(__snake_case ,(str, list, tuple) ):
            A_          =       data_files
            if isinstance(__snake_case ,__snake_case ):
                 A_          =       [files]
            # Use `dl_manager.iter_files` to skip hidden files in an extracted archive
            A_          =       [dl_manager.iter_files(__snake_case ) for file in files]
            return [datasets.SplitGenerator(name=datasets.Split.TRAIN ,gen_kwargs={'''files''': files} )]
       A_          =       []
       for split_name, files in data_files.items():
            if isinstance(__snake_case ,__snake_case ):
                 A_          =       [files]
            # Use `dl_manager.iter_files` to skip hidden files in an extracted archive
            A_          =       [dl_manager.iter_files(__snake_case ) for file in files]
            # Infer features is they are stoed in the arrow schema
            if self.info.features is None:
                 for file in itertools.chain.from_iterable(__snake_case ):
                      with open(__snake_case ,'''rb''' ) as f:
                           A_          =       datasets.Features.from_arrow_schema(pq.read_schema(__snake_case ) )
                      break
            splits.append(datasets.SplitGenerator(name=__snake_case ,gen_kwargs={'''files''': files} ) )
       return splits


  def 						__UpperCAmelCase     (							self ,__snake_case ):



       """simple docstring"""





       if self.info.features is not None:
            # more expensive cast to support nested features with keys in a different order
            # allows str <-> int/float or str to Audio for example
            A_          =       table_cast(__snake_case ,self.info.features.arrow_schema )
       return pa_table




  def 						__UpperCAmelCase     (							self ,__snake_case ):



       """simple docstring"""





       A_          =       self.info.features.arrow_schema if self.info.features is not None else None
       if self.info.features is not None and self.config.columns is not None:
            if sorted(field.name for field in schema ) != sorted(self.config.columns ):
                 raise ValueError(
                     f'Tried to load parquet data with columns \'{self.config.columns}\' with mismatching features \'{self.info.features}\'' )
       for file_idx, file in enumerate(itertools.chain.from_iterable(__snake_case ) ):
            with open(__snake_case ,'''rb''' ) as f:
                 A_          =       pq.ParquetFile(__snake_case )
                 try:
                      for batch_idx, record_batch in enumerate(
                          parquet_file.iter_batches(batch_size=self.config.batch_size ,columns=self.config.columns ) ):
                           A_          =       pa.Table.from_batches([record_batch] )
                           # 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 f'{file_idx}_{batch_idx}', self._cast_table(__snake_case )
                 except ValueError as e:
                      logger.error(f'Failed to read file \'{file}\' with error {type(__snake_case )}: {e}' )
                      raise










from math import pi, sqrt, tan

def      UpperCAmelCase_    (    _UpperCAmelCase							:float				)	->				float:
     '''simple docstring'''


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

def      UpperCAmelCase_    (    _UpperCAmelCase							:float  ,						_UpperCAmelCase							:float  ,						_UpperCAmelCase							:float				)	->				float:
     '''simple docstring'''


     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      UpperCAmelCase_    (    _UpperCAmelCase							:float				)	->				float:
     '''simple docstring'''


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

def      UpperCAmelCase_    (    _UpperCAmelCase							:float				)	->				float:
     '''simple docstring'''


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

def      UpperCAmelCase_    (    _UpperCAmelCase							:float  ,						_UpperCAmelCase							:float				)	->				float:
     '''simple docstring'''


     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      UpperCAmelCase_    (    _UpperCAmelCase							:float  ,						_UpperCAmelCase							:float  ,						_UpperCAmelCase							:float				)	->				float:
     '''simple docstring'''


     if radius_a < 0 or radius_a < 0 or height < 0:
          raise ValueError(
              '''surface_area_conical_frustum() only accepts non-negative values'''				)
     A_          =       (height**2 + (radius_a - radius_a) ** 2) ** 0.5
     return pi * ((slant_height * (radius_a + radius_a)) + radius_a**2 + radius_a**2)

def      UpperCAmelCase_    (    _UpperCAmelCase							:float  ,						_UpperCAmelCase							:float				)	->				float:
     '''simple docstring'''


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

def      UpperCAmelCase_    (    _UpperCAmelCase							:float  ,						_UpperCAmelCase							:float				)	->				float:
     '''simple docstring'''


     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(_UpperCAmelCase  ,						2				) * torus_radius * tube_radius

def      UpperCAmelCase_    (    _UpperCAmelCase							:float  ,						_UpperCAmelCase							:float				)	->				float:
     '''simple docstring'''


     if length < 0 or width < 0:
          raise ValueError('''area_rectangle() only accepts non-negative values'''				)
     return length * width

def      UpperCAmelCase_    (    _UpperCAmelCase							:float				)	->				float:
     '''simple docstring'''


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

def      UpperCAmelCase_    (    _UpperCAmelCase							:float  ,						_UpperCAmelCase							:float				)	->				float:
     '''simple docstring'''


     if base < 0 or height < 0:
          raise ValueError('''area_triangle() only accepts non-negative values'''				)
     return (base * height) / 2

def      UpperCAmelCase_    (    _UpperCAmelCase							:float  ,						_UpperCAmelCase							:float  ,						_UpperCAmelCase							:float				)	->				float:
     '''simple docstring'''


     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'''				)
     A_          =       (sidea + sidea + sidea) / 2
     A_          =       sqrt(
         semi_perimeter
         * (semi_perimeter - sidea)
         * (semi_perimeter - sidea)
         * (semi_perimeter - sidea)				)
     return area

def      UpperCAmelCase_    (    _UpperCAmelCase							:float  ,						_UpperCAmelCase							:float				)	->				float:
     '''simple docstring'''


     if base < 0 or height < 0:
          raise ValueError('''area_parallelogram() only accepts non-negative values'''				)
     return base * height

def      UpperCAmelCase_    (    _UpperCAmelCase							:float  ,						_UpperCAmelCase							:float  ,						_UpperCAmelCase							:float				)	->				float:
     '''simple docstring'''


     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      UpperCAmelCase_    (    _UpperCAmelCase							:float				)	->				float:
     '''simple docstring'''


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

def      UpperCAmelCase_    (    _UpperCAmelCase							:float  ,						_UpperCAmelCase							:float				)	->				float:
     '''simple docstring'''


     if radius_x < 0 or radius_y < 0:
          raise ValueError('''area_ellipse() only accepts non-negative values'''				)
     return pi * radius_x * radius_y

def      UpperCAmelCase_    (    _UpperCAmelCase							:float  ,						_UpperCAmelCase							:float				)	->				float:
     '''simple docstring'''


     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      UpperCAmelCase_    (    _UpperCAmelCase							:int  ,						_UpperCAmelCase							:float				)	->				float:
     '''simple docstring'''


     if not isinstance(_UpperCAmelCase  ,						_UpperCAmelCase				) 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) = }''')



