




'''simple docstring'''



import sys
from dataclasses import dataclass
from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Union

import pandas as pd
import pyarrow as pa

import datasets
import datasets.config
from datasets.features.features import require_storage_cast
from datasets.table import table_cast


if TYPE_CHECKING:
 import sqlitea

 import sqlalchemy


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







@dataclass
class 		lowercase_    ( datasets.BuilderConfig   ):


   """simple docstring"""

   lowerCamelCase_				  =						None
   lowerCamelCase_				  =						None
   lowerCamelCase_				  =						None
   lowerCamelCase_				  =						True
   lowerCamelCase_				  =						None
   lowerCamelCase_				  =						None
   lowerCamelCase_				  =						None
   lowerCamelCase_				  =						10000
   lowerCamelCase_				  =						None



   def 							lowerCAmelCase_			(    self					:	Tuple    ):

      """simple docstring"""
      if self.sql is None:
         raise ValueError("sql must be specified"    )
      if self.con is None:
         raise ValueError("con must be specified"    )



   def 							lowerCAmelCase_			(    self					:	Union[str, Any]  ,      __lowerCamelCase					:	int  ,      __lowerCamelCase					:	Optional[Any] = None  ,      ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE       =      config_kwargs.copy()
      # We need to stringify the Selectable object to make its hash deterministic

      # The process of stringifying is explained here: http://docs.sqlalchemy.org/en/latest/faq/sqlexpressions.html
      _SCREAMING_SNAKE_CASE       =      config_kwargs["sql"]
      if not isinstance(__UpperCamelCase  ,      __UpperCamelCase    ):
         if datasets.config.SQLALCHEMY_AVAILABLE and "sqlalchemy" in sys.modules:
            import sqlalchemy

            if isinstance(__UpperCamelCase  ,      sqlalchemy.sql.Selectable    ):
               _SCREAMING_SNAKE_CASE       =      sqlalchemy.create_engine(config_kwargs["con"].split("://"    )[0] + "://"    )
               _SCREAMING_SNAKE_CASE       =      str(sql.compile(dialect=engine.dialect    )    )
               _SCREAMING_SNAKE_CASE       =      sql_str
            else:
               raise TypeError(
                   F"""Supported types for \'sql\' are string and sqlalchemy.sql.Selectable but got {type(__UpperCamelCase    )}: {sql}"""    )
         else:
            raise TypeError(
                F"""Supported types for \'sql\' are string and sqlalchemy.sql.Selectable but got {type(__UpperCamelCase    )}: {sql}"""    )
      _SCREAMING_SNAKE_CASE       =      config_kwargs["con"]
      if not isinstance(__UpperCamelCase  ,      __UpperCamelCase    ):
         _SCREAMING_SNAKE_CASE       =      id(__UpperCamelCase    )
         logger.info(
             F"""SQL connection \'con\' of type {type(__UpperCamelCase    )} couldn\'t be hashed properly. To enable hashing, specify \'con\' as URI string instead."""    )

      return super().create_config_id(__UpperCamelCase  ,      custom_features=__UpperCamelCase    )



   @property
   def 							lowerCAmelCase_			(    self					:	Optional[int]    ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE       =      {
          "index_col": self.index_col,
          "columns": self.columns,
          "params": self.params,
          "coerce_float": self.coerce_float,
          "parse_dates": self.parse_dates,
      }
      return pd_read_sql_kwargs







class 		lowercase_    ( datasets.ArrowBasedBuilder   ):


   """simple docstring"""

   lowerCamelCase_				  =						SqlConfig



   def 							lowerCAmelCase_			(    self					:	Optional[int]    ):

      """simple docstring"""
      return datasets.DatasetInfo(features=self.config.features    )



   def 							lowerCAmelCase_			(    self					:	int  ,      __lowerCamelCase					:	Optional[int]    ):

      """simple docstring"""
      return [datasets.SplitGenerator(name=datasets.Split.TRAIN  ,      gen_kwargs={}    )]



   def 							lowerCAmelCase_			(    self					:	Optional[int]  ,      __lowerCamelCase					:	Any    ):

      """simple docstring"""
      if self.config.features is not None:
         _SCREAMING_SNAKE_CASE       =      self.config.features.arrow_schema
         if all(not require_storage_cast(__UpperCamelCase    ) for feature in self.config.features.values()    ):
            # cheaper cast
            _SCREAMING_SNAKE_CASE       =      pa.Table.from_arrays([pa_table[field.name] for field in schema]  ,      schema=__UpperCamelCase    )
         else:
            # more expensive cast; allows str <-> int/float or str to Audio for example
            _SCREAMING_SNAKE_CASE       =      table_cast(__UpperCamelCase  ,      __UpperCamelCase    )
      return pa_table



   def 							lowerCAmelCase_			(    self					:	Optional[Any]    ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE       =      self.config.chunksize
      _SCREAMING_SNAKE_CASE       =      pd.read_sql(
          self.config.sql  ,      self.config.con  ,      chunksize=__UpperCamelCase  ,      **self.config.pd_read_sql_kwargs    )
      _SCREAMING_SNAKE_CASE       =      [sql_reader] if chunksize is None else sql_reader
      for chunk_idx, df in enumerate(__UpperCamelCase    ):
         _SCREAMING_SNAKE_CASE       =      pa.Table.from_pandas(__UpperCamelCase    )
         yield chunk_idx, self._cast_table(__UpperCamelCase    )







'''simple docstring'''







from __future__ import annotations

from math import pi, pow






def 		_lowercase		(	lowercase_  ):



		'''simple docstring'''







		if side_length < 0:
				raise ValueError("vol_cube() only accepts non-negative values"  )
		return pow(lowercase_						,							3  )






def 		_lowercase		(	lowercase_						,							lowercase_  ):



		'''simple docstring'''







		if height < 0 or radius < 0:
				raise ValueError("vol_spherical_cap() only accepts non-negative values"  )
		# Volume is 1/3 pi * height squared * (3 * radius - height)
		return 1 / 3 * pi * pow(lowercase_						,							2  ) * (3 * radius - height)






def 		_lowercase		(	lowercase_						,							lowercase_						,							lowercase_  ):



		'''simple docstring'''







		if radius_a < 0 or radius_a < 0 or centers_distance < 0:
				raise ValueError("vol_spheres_intersect() only accepts non-negative values"  )
		if centers_distance == 0:
				return vol_sphere(min(lowercase_						,							lowercase_  )  )

		_snake_case	       =       (
		    (radius_a - radius_a + centers_distance)
		    * (radius_a + radius_a - centers_distance)
		    / (2 * centers_distance)
		)
		_snake_case	       =       (
		    (radius_a - radius_a + centers_distance)
		    * (radius_a + radius_a - centers_distance)
		    / (2 * centers_distance)
		)

		return vol_spherical_cap(lowercase_						,							lowercase_  ) + vol_spherical_cap(lowercase_						,							lowercase_  )






def 		_lowercase		(	lowercase_						,							lowercase_						,							lowercase_  ):



		'''simple docstring'''







		if radius_a <= 0 or radius_a <= 0 or centers_distance < 0:
				raise ValueError(
				    "vol_spheres_union() only accepts non-negative values, non-zero radius"  )

		if centers_distance == 0:
				return vol_sphere(max(lowercase_						,							lowercase_  )  )

		return (
		    vol_sphere(lowercase_  )
		    + vol_sphere(lowercase_  )
		    - vol_spheres_intersect(lowercase_						,							lowercase_						,							lowercase_  )
		)






def 		_lowercase		(	lowercase_						,							lowercase_						,							lowercase_  ):



		'''simple docstring'''







		if width < 0 or height < 0 or length < 0:
				raise ValueError("vol_cuboid() only accepts non-negative values"  )
		return float(width * height * length  )






def 		_lowercase		(	lowercase_						,							lowercase_  ):



		'''simple docstring'''







		if height < 0 or area_of_base < 0:
				raise ValueError("vol_cone() only accepts non-negative values"  )
		return area_of_base * height / 3.0






def 		_lowercase		(	lowercase_						,							lowercase_  ):



		'''simple docstring'''







		if height < 0 or radius < 0:
				raise ValueError("vol_right_circ_cone() only accepts non-negative values"  )
		return pi * pow(lowercase_						,							2  ) * height / 3.0






def 		_lowercase		(	lowercase_						,							lowercase_  ):



		'''simple docstring'''







		if height < 0 or area_of_base < 0:
				raise ValueError("vol_prism() only accepts non-negative values"  )
		return float(area_of_base * height  )






def 		_lowercase		(	lowercase_						,							lowercase_  ):



		'''simple docstring'''







		if height < 0 or area_of_base < 0:
				raise ValueError("vol_pyramid() only accepts non-negative values"  )
		return area_of_base * height / 3.0






def 		_lowercase		(	lowercase_  ):



		'''simple docstring'''







		if radius < 0:
				raise ValueError("vol_sphere() only accepts non-negative values"  )
		# Volume is 4/3 * pi * radius cubed
		return 4 / 3 * pi * pow(lowercase_						,							3  )






def 		_lowercase		(	lowercase_  ):



		'''simple docstring'''







		if radius < 0:
				raise ValueError("vol_hemisphere() only accepts non-negative values"  )
		# Volume is radius cubed * pi * 2/3
		return pow(lowercase_						,							3  ) * pi * 2 / 3






def 		_lowercase		(	lowercase_						,							lowercase_  ):



		'''simple docstring'''







		if height < 0 or radius < 0:
				raise ValueError("vol_circular_cylinder() only accepts non-negative values"  )
		# Volume is radius squared * height * pi
		return pow(lowercase_						,							2  ) * height * pi






def 		_lowercase		(	lowercase_						,							lowercase_						,							lowercase_  ):



		'''simple docstring'''







		if inner_radius < 0 or outer_radius < 0 or height < 0:
				raise ValueError(
				    "vol_hollow_circular_cylinder() only accepts non-negative values"  )
		if outer_radius <= inner_radius:
				raise ValueError("outer_radius must be greater than inner_radius"  )
		return pi * (pow(lowercase_						,							2  ) - pow(lowercase_						,							2  )) * height






def 		_lowercase		(	lowercase_						,							lowercase_						,							lowercase_  ):



		'''simple docstring'''







		if radius_a < 0 or radius_a < 0 or height < 0:
				raise ValueError("vol_conical_frustum() only accepts non-negative values"  )
		return (
		    1
		    / 3
		    * pi
		    * height
		    * (pow(lowercase_						,							2  ) + pow(lowercase_						,							2  ) + radius_a * radius_a)
		)






def 		_lowercase		(	lowercase_						,							lowercase_  ):



		'''simple docstring'''







		if torus_radius < 0 or tube_radius < 0:
				raise ValueError("vol_torus() only accepts non-negative values"  )
		return 2 * pow(lowercase_						,							2  ) * torus_radius * pow(lowercase_						,							2  )






def 		_lowercase		(	):



		'''simple docstring'''







		print("Volumes:"  )
		print(f'''Cube: {vol_cube(2  ) = }'''  )  # = 8
		print(f'''Cuboid: {vol_cuboid(2						,							2						,							2  ) = }'''  )  # = 8
		print(f'''Cone: {vol_cone(2						,							2  ) = }'''  )  # ~= 1.33
		print(f'''Right Circular Cone: {vol_right_circ_cone(2						,							2  ) = }'''  )  # ~= 8.38
		print(f'''Prism: {vol_prism(2						,							2  ) = }'''  )  # = 4
		print(f'''Pyramid: {vol_pyramid(2						,							2  ) = }'''  )  # ~= 1.33
		print(f'''Sphere: {vol_sphere(2  ) = }'''  )  # ~= 33.5
		print(f'''Hemisphere: {vol_hemisphere(2  ) = }'''  )  # ~= 16.75
		print(f'''Circular Cylinder: {vol_circular_cylinder(2						,							2  ) = }'''  )  # ~= 25.1
		print(f'''Torus: {vol_torus(2						,							2  ) = }'''  )  # ~= 157.9
		print(f'''Conical Frustum: {vol_conical_frustum(2						,							2						,							4  ) = }'''  )  # ~= 58.6
		print(f'''Spherical cap: {vol_spherical_cap(1						,							2  ) = }'''  )  # ~= 5.24
		print(f'''Spheres intersetion: {vol_spheres_intersect(2						,							2						,							1  ) = }'''  )  # ~= 21.21
		print(f'''Spheres union: {vol_spheres_union(2						,							2						,							1  ) = }'''  )  # ~= 45.81
		print(
		    f'''Hollow Circular Cylinder: {vol_hollow_circular_cylinder(1						,							2						,							3  ) = }'''  )  # ~= 28.3


if __name__ == "__main__":
						main()





