





from __future__ import annotations

from math import pi, pow
def   _A (	SCREAMING_SNAKE_CASE  :     int | float		):





  """simple docstring"""



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





  """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(SCREAMING_SNAKE_CASE , 2		) * (3 * radius - height)
def   _A (	SCREAMING_SNAKE_CASE  :     float , SCREAMING_SNAKE_CASE  :     float , SCREAMING_SNAKE_CASE  :     float		):





  """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(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE		)		)

  a__			:      Dict            =(
      (radius_a - radius_a + centers_distance)
      * (radius_a + radius_a - centers_distance)
      / (2 * centers_distance)
  )
  a__			:      Dict            =(
      (radius_a - radius_a + centers_distance)
      * (radius_a + radius_a - centers_distance)
      / (2 * centers_distance)
  )

  return vol_spherical_cap(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE		) + vol_spherical_cap(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE		)
def   _A (	SCREAMING_SNAKE_CASE  :     float , SCREAMING_SNAKE_CASE  :     float , SCREAMING_SNAKE_CASE  :     float		):





  """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(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE		)		)

  return (
      vol_sphere(SCREAMING_SNAKE_CASE		)
      + vol_sphere(SCREAMING_SNAKE_CASE		)
      - vol_spheres_intersect(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE		)
  )
def   _A (	SCREAMING_SNAKE_CASE  :     float , SCREAMING_SNAKE_CASE  :     float , SCREAMING_SNAKE_CASE  :     float		):





  """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   _A (	SCREAMING_SNAKE_CASE  :     float , SCREAMING_SNAKE_CASE  :     float		):





  """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   _A (	SCREAMING_SNAKE_CASE  :     float , SCREAMING_SNAKE_CASE  :     float		):





  """simple docstring"""



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





  """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   _A (	SCREAMING_SNAKE_CASE  :     float , SCREAMING_SNAKE_CASE  :     float		):





  """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   _A (	SCREAMING_SNAKE_CASE  :     float		):





  """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(SCREAMING_SNAKE_CASE , 3		)
def   _A (	SCREAMING_SNAKE_CASE  :     float		):





  """simple docstring"""



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





  """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(SCREAMING_SNAKE_CASE , 2		) * height * pi
def   _A (	SCREAMING_SNAKE_CASE  :     float , SCREAMING_SNAKE_CASE  :     float , SCREAMING_SNAKE_CASE  :     float		):





  """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(SCREAMING_SNAKE_CASE , 2		) - pow(SCREAMING_SNAKE_CASE , 2		)) * height
def   _A (	SCREAMING_SNAKE_CASE  :     float , SCREAMING_SNAKE_CASE  :     float , SCREAMING_SNAKE_CASE  :     float		):





  """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(SCREAMING_SNAKE_CASE , 2		) + pow(SCREAMING_SNAKE_CASE , 2		) + radius_a * radius_a)
  )
def   _A (	SCREAMING_SNAKE_CASE  :     float , SCREAMING_SNAKE_CASE  :     float		):





  """simple docstring"""



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





  """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()













import os
import tempfile
from pathlib import Path
from unittest import TestCase

import pyarrow as pa
import pytest

from datasets.arrow_dataset import Dataset
from datasets.arrow_reader import ArrowReader, BaseReader, FileInstructions, ReadInstruction, make_file_instructions
from datasets.info import DatasetInfo
from datasets.splits import NamedSplit, Split, SplitDict, SplitInfo

from .utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases







class        __lowerCAmelCase (					UpperCamelCase__):







      def      _lowercase						(					self	,   lowerCAmelCase__	,   lowerCAmelCase__=False							)     ->		List[Any]:



        '''simple docstring'''




        a__      ,							a__      ,							a__			:      Optional[int]            =(
            filename_skip_take["filename"],
            filename_skip_take["skip"] if "skip" in filename_skip_take else None,
            filename_skip_take["take"] if "take" in filename_skip_take else None,
        )
        open(os.path.join(lowerCAmelCase__							)	,   "wb"							).close()
        a__			:      Optional[int]            =pa.Table.from_pydict({"filename": [Path(lowerCAmelCase__							).name] * 1_0_0}							)
        if take == -1:
          a__			:      int            =len(lowerCAmelCase__							) - skip
        if skip is not None and take is not None:
          a__			:      Optional[Any]            =pa_table.slice(lowerCAmelCase__	,   lowerCAmelCase__							)
        return pa_table







class        __lowerCAmelCase (					UpperCamelCase__):







      def      _lowercase						(					self							)     ->		str:



        '''simple docstring'''




        a__			:      List[str]            ="my_name"
        a__			:      List[Any]            =SplitInfo(name="train"	,   num_examples=1_0_0							)
        a__			:      List[str]            =SplitInfo(name="test"	,   num_examples=1_0_0							)
        a__			:      List[Any]            =[train_info, test_info]
        a__			:      Union[str, Any]            =SplitDict()
        split_dict.add(lowerCAmelCase__							)
        split_dict.add(lowerCAmelCase__							)
        a__			:      Dict            =DatasetInfo(splits=lowerCAmelCase__							)

        with tempfile.TemporaryDirectory() as tmp_dir:
          a__			:      Optional[Any]            =ReaderTest(lowerCAmelCase__	,   lowerCAmelCase__							)

          a__			:      Any            ="test[:33%]"
          a__			:      int            =Dataset(**reader.read(lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__							)							)
          self.assertEqual(dset["filename"][0]	,   F'''{name}-test'''							)
          self.assertEqual(dset.num_rows	,   3_3							)
          self.assertEqual(dset.num_columns	,   1							)

          a__			:      Tuple            =["train", "test[:33%]"]
          a__			:      str            =[Split.TRAIN, ReadInstruction.from_spec("test[:33%]"							)]
          for instructions in [instructionsa, instructionsa]:
            a__			:      Optional[int]            =[reader.read(lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__							) for instr in instructions]
            a__      ,							a__			:      Optional[int]            =(Dataset(**lowerCAmelCase__							) for dataset_kwargs in datasets_kwargs)
            self.assertEqual(train_dset["filename"][0]	,   F'''{name}-train'''							)
            self.assertEqual(train_dset.num_rows	,   1_0_0							)
            self.assertEqual(train_dset.num_columns	,   1							)
            self.assertIsInstance(train_dset.split	,   lowerCAmelCase__							)
            self.assertEqual(str(train_dset.split							)	,   "train"							)
            self.assertEqual(test_dset["filename"][0]	,   F'''{name}-test'''							)
            self.assertEqual(test_dset.num_rows	,   3_3							)
            self.assertEqual(test_dset.num_columns	,   1							)
            self.assertIsInstance(test_dset.split	,   lowerCAmelCase__							)
            self.assertEqual(str(test_dset.split							)	,   "test[:33%]"							)
            del train_dset, test_dset







      def      _lowercase						(					self							)     ->		Optional[Any]:



        '''simple docstring'''




        a__			:      Any            ="my_name"
        a__			:      List[Any]            =SplitInfo(name="train"	,   num_examples=1_0_0_0	,   shard_lengths=[1_0_0] * 1_0							)
        a__			:      Optional[Any]            =[train_info]
        a__			:      Any            =SplitDict()
        split_dict.add(lowerCAmelCase__							)
        a__			:      Any            =DatasetInfo(splits=lowerCAmelCase__							)

        with tempfile.TemporaryDirectory() as tmp_dir:
          a__			:      Optional[int]            =ReaderTest(lowerCAmelCase__	,   lowerCAmelCase__							)

          a__			:      Union[str, Any]            ="train[:33%]"
          a__			:      Union[str, Any]            =Dataset(**reader.read(lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__							)							)
          self.assertEqual(dset["filename"][0]	,   F'''{name}-train-00000-of-00010'''							)
          self.assertEqual(dset["filename"][-1]	,   F'''{name}-train-00003-of-00010'''							)
          self.assertEqual(dset.num_rows	,   3_3_0							)
          self.assertEqual(dset.num_columns	,   1							)







      def      _lowercase						(					self							)     ->		List[str]:



        '''simple docstring'''




        a__			:      Dict            =SplitInfo(name="train"	,   num_examples=1_0_0							)
        a__			:      str            =SplitInfo(name="test"	,   num_examples=1_0_0							)
        a__			:      int            =SplitDict()
        split_dict.add(lowerCAmelCase__							)
        split_dict.add(lowerCAmelCase__							)
        a__			:      int            =DatasetInfo(splits=lowerCAmelCase__							)

        with tempfile.TemporaryDirectory() as tmp_dir:
          a__			:      Tuple            =ReaderTest(lowerCAmelCase__	,   lowerCAmelCase__							)

          a__			:      Tuple            =[
              {"filename": os.path.join(lowerCAmelCase__	,   "train"							)},
              {"filename": os.path.join(lowerCAmelCase__	,   "test"							), "skip": 1_0, "take": 1_0},
          ]
          a__			:      Optional[Any]            =Dataset(**reader.read_files(lowerCAmelCase__	,   original_instructions="train+test[10:20]"							)							)
          self.assertEqual(dset.num_rows	,   1_1_0							)
          self.assertEqual(dset.num_columns	,   1							)
          del dset
@pytest.mark.parametrize("in_memory" , [False, True]		)
def   _A (	SCREAMING_SNAKE_CASE  :     Optional[Any] , SCREAMING_SNAKE_CASE  :     Optional[Any] , SCREAMING_SNAKE_CASE  :     Optional[Any]		):





  """simple docstring"""



  a__			:      int            =arrow_file
  with assert_arrow_memory_increases() if in_memory else assert_arrow_memory_doesnt_increase():
    a__			:      str            =ArrowReader.read_table(SCREAMING_SNAKE_CASE , in_memory=SCREAMING_SNAKE_CASE		)
  assert table.shape == dataset.data.shape
  assert set(table.column_names		) == set(dataset.data.column_names		)
  assert dict(table.to_pydict()		) == dict(dataset.data.to_pydict()		)  # to_pydict returns OrderedDict
@pytest.mark.parametrize("in_memory" , [False, True]		)
def   _A (	SCREAMING_SNAKE_CASE  :     Tuple , SCREAMING_SNAKE_CASE  :     List[Any] , SCREAMING_SNAKE_CASE  :     str		):





  """simple docstring"""



  a__			:      Optional[int]            =arrow_file
  a__			:      Tuple            =ArrowReader("" , SCREAMING_SNAKE_CASE		)
  with assert_arrow_memory_increases() if in_memory else assert_arrow_memory_doesnt_increase():
    a__			:      Union[str, Any]            =reader.read_files([{"filename": filename}] , in_memory=SCREAMING_SNAKE_CASE		)
  assert dataset_kwargs.keys() == {"arrow_table", "info", "split"}
  a__			:      Dict            =dataset_kwargs["arrow_table"]
  assert table.shape == dataset.data.shape
  assert set(table.column_names		) == set(dataset.data.column_names		)
  assert dict(table.to_pydict()		) == dict(dataset.data.to_pydict()		)  # to_pydict returns OrderedDict
def   _A (	):





  """simple docstring"""



  assert ReadInstruction("train" , to=10 , unit="abs"		).to_spec() == "train[:10]"
  assert ReadInstruction("train" , from_=-80 , to=10 , unit="%"		).to_spec() == "train[-80%:10%]"

  a__			:      List[Any]            ="train+test"
  assert ReadInstruction.from_spec(SCREAMING_SNAKE_CASE		).to_spec() == spec_train_test

  a__			:      Union[str, Any]            ="train[2:10]"
  assert ReadInstruction.from_spec(SCREAMING_SNAKE_CASE		).to_spec() == spec_train_abs

  a__			:      List[Any]            ="train[15%:-20%]"
  assert ReadInstruction.from_spec(SCREAMING_SNAKE_CASE		).to_spec() == spec_train_pct

  a__			:      Dict            ="train[:10%](closest)"
  assert ReadInstruction.from_spec(SCREAMING_SNAKE_CASE		).to_spec() == "train[:10%]"

  a__			:      Tuple            ="train[:10%](pct1_dropremainder)"
  assert ReadInstruction.from_spec(SCREAMING_SNAKE_CASE		).to_spec() == spec_train_pct_rounding

  a__			:      List[Any]            ="train[:10%](pct1_dropremainder)+test[-10%:](pct1_dropremainder)"
  assert ReadInstruction.from_spec(SCREAMING_SNAKE_CASE		).to_spec() == spec_train_test_pct_rounding
def   _A (	):





  """simple docstring"""



  a__			:      Optional[Any]            ="dummy"
  a__			:      Dict            =[SplitInfo(name="train" , num_examples=100		)]
  a__			:      Optional[Any]            ="train[:33%]"
  a__			:      int            ="arrow"
  a__			:      Any            ="prefix"

  a__			:      Tuple            =make_file_instructions(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE		)
  assert isinstance(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE		)
  assert file_instructions.num_examples == 33
  assert file_instructions.file_instructions == [
      {"filename": os.path.join(SCREAMING_SNAKE_CASE , f'''{name}-train.arrow'''		), "skip": 0, "take": 33}
  ]

  a__			:      List[str]            =[SplitInfo(name="train" , num_examples=100 , shard_lengths=[10] * 10		)]
  a__			:      Union[str, Any]            =make_file_instructions(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE		)
  assert isinstance(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE		)
  assert file_instructions.num_examples == 33
  assert file_instructions.file_instructions == [
      {"filename": os.path.join(SCREAMING_SNAKE_CASE , f'''{name}-train-00000-of-00010.arrow'''		), "skip": 0, "take": -1},
      {"filename": os.path.join(SCREAMING_SNAKE_CASE , f'''{name}-train-00001-of-00010.arrow'''		), "skip": 0, "take": -1},
      {"filename": os.path.join(SCREAMING_SNAKE_CASE , f'''{name}-train-00002-of-00010.arrow'''		), "skip": 0, "take": -1},
      {"filename": os.path.join(SCREAMING_SNAKE_CASE , f'''{name}-train-00003-of-00010.arrow'''		), "skip": 0, "take": 3},
  ]





@pytest.mark.parametrize("name, expected_exception" , [(None, TypeError), ("", ValueError)]		)
def   _A (	SCREAMING_SNAKE_CASE  :     Tuple , SCREAMING_SNAKE_CASE  :     Tuple		):





  """simple docstring"""



  a__			:      Dict            =[SplitInfo(name="train" , num_examples=100		)]
  a__			:      Any            ="train"
  a__			:      Optional[Any]            ="arrow"
  a__			:      List[Any]            ="prefix_path"
  with pytest.raises(SCREAMING_SNAKE_CASE		):
    a__			:      Optional[Any]            =make_file_instructions(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE		)






