






"""simple docstring"""


import csv
import os

import pytest

from datasets import Dataset, DatasetDict, Features, NamedSplit, Value
from datasets.io.csv import CsvDatasetReader, CsvDatasetWriter

from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		)      ->					List[Any]:

 '''simple docstring'''






 assert isinstance(_A		,       _A		)
 assert dataset.num_rows == 4
 assert dataset.num_columns == 3
 assert dataset.column_names == ["col_1", "col_2", "col_3"]
 for feature, expected_dtype in expected_features.items():
  assert dataset.features[feature].dtype == expected_dtype





@pytest.mark.parametrize("keep_in_memory"		,       [False, True]		)
def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		,       _UpperCAmelCase		)      ->					Optional[int]:

 '''simple docstring'''






 snake_case__      							=			tmp_path / "cache"
 snake_case__      							=			{"col_1": "int64", "col_2": "int64", "col_3": "float64"}
 with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
  snake_case__      							=			CsvDatasetReader(_A		,       cache_dir=_A		,       keep_in_memory=_A		).read()
 _check_csv_dataset(_A		,       _A		)





@pytest.mark.parametrize(
    "features"		,       [
        None,
        {"col_1": "string", "col_2": "int64", "col_3": "float64"},
        {"col_1": "string", "col_2": "string", "col_3": "string"},
        {"col_1": "int32", "col_2": "int32", "col_3": "int32"},
        {"col_1": "float32", "col_2": "float32", "col_3": "float32"},
    ]		,       )
def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		,       _UpperCAmelCase		)      ->					Union[str, Any]:

 '''simple docstring'''






 snake_case__      							=			tmp_path / "cache"
 # CSV file loses col_1 string dtype information: default now is "int64" instead of "string"
 snake_case__      							=			{"col_1": "int64", "col_2": "int64", "col_3": "float64"}
 snake_case__      							=			features.copy() if features else default_expected_features
 snake_case__      							=			(
     Features({feature: Value(_A		) for feature, dtype in features.items()}		) if features is not None else None
 )
 snake_case__      							=			CsvDatasetReader(_A		,       features=_A		,       cache_dir=_A		).read()
 _check_csv_dataset(_A		,       _A		)





@pytest.mark.parametrize("split"		,       [None, NamedSplit("train"		), "train", "test"]		)
def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		,       _UpperCAmelCase		)      ->					List[Any]:

 '''simple docstring'''






 snake_case__      							=			tmp_path / "cache"
 snake_case__      							=			{"col_1": "int64", "col_2": "int64", "col_3": "float64"}
 snake_case__      							=			CsvDatasetReader(_A		,       cache_dir=_A		,       split=_A		).read()
 _check_csv_dataset(_A		,       _A		)
 assert dataset.split == split if split else "train"





@pytest.mark.parametrize("path_type"		,       [str, list]		)
def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		,       _UpperCAmelCase		)      ->					Optional[Any]:

 '''simple docstring'''






 if issubclass(_A		,       _A		):
  snake_case__      							=			csv_path
 elif issubclass(_A		,       _A		):
  snake_case__      							=			[csv_path]
 snake_case__      							=			tmp_path / "cache"
 snake_case__      							=			{"col_1": "int64", "col_2": "int64", "col_3": "float64"}
 snake_case__      							=			CsvDatasetReader(_A		,       cache_dir=_A		).read()
 _check_csv_dataset(_A		,       _A		)





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		,       _UpperCAmelCase=("train",)		)      ->					Tuple:

 '''simple docstring'''






 assert isinstance(_A		,       _A		)
 for split in splits:
  snake_case__      							=			dataset_dict[split]
  assert dataset.num_rows == 4
  assert dataset.num_columns == 3
  assert dataset.column_names == ["col_1", "col_2", "col_3"]
  for feature, expected_dtype in expected_features.items():
   assert dataset.features[feature].dtype == expected_dtype





@pytest.mark.parametrize("keep_in_memory"		,       [False, True]		)
def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		,       _UpperCAmelCase		)      ->					Dict:

 '''simple docstring'''






 snake_case__      							=			tmp_path / "cache"
 snake_case__      							=			{"col_1": "int64", "col_2": "int64", "col_3": "float64"}
 with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
  snake_case__      							=			CsvDatasetReader({"train": csv_path}		,       cache_dir=_A		,       keep_in_memory=_A		).read()
 _check_csv_datasetdict(_A		,       _A		)





@pytest.mark.parametrize(
    "features"		,       [
        None,
        {"col_1": "string", "col_2": "int64", "col_3": "float64"},
        {"col_1": "string", "col_2": "string", "col_3": "string"},
        {"col_1": "int32", "col_2": "int32", "col_3": "int32"},
        {"col_1": "float32", "col_2": "float32", "col_3": "float32"},
    ]		,       )
def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		,       _UpperCAmelCase		)      ->					Union[str, Any]:

 '''simple docstring'''






 snake_case__      							=			tmp_path / "cache"
 # CSV file loses col_1 string dtype information: default now is "int64" instead of "string"
 snake_case__      							=			{"col_1": "int64", "col_2": "int64", "col_3": "float64"}
 snake_case__      							=			features.copy() if features else default_expected_features
 snake_case__      							=			(
     Features({feature: Value(_A		) for feature, dtype in features.items()}		) if features is not None else None
 )
 snake_case__      							=			CsvDatasetReader({"train": csv_path}		,       features=_A		,       cache_dir=_A		).read()
 _check_csv_datasetdict(_A		,       _A		)





@pytest.mark.parametrize("split"		,       [None, NamedSplit("train"		), "train", "test"]		)
def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		,       _UpperCAmelCase		)      ->					Optional[int]:

 '''simple docstring'''






 if split:
  snake_case__      							=			{split: csv_path}
 else:
  snake_case__      							=			{"train": csv_path, "test": csv_path}
 snake_case__      							=			tmp_path / "cache"
 snake_case__      							=			{"col_1": "int64", "col_2": "int64", "col_3": "float64"}
 snake_case__      							=			CsvDatasetReader(_A		,       cache_dir=_A		).read()
 _check_csv_datasetdict(_A		,       _A		,       splits=list(path.keys()		)		)
 assert all(dataset[split].split == split for split in path.keys()		)





def 							a__     (					_UpperCAmelCase		)      ->					List[Any]:

 '''simple docstring'''






 with open(_A		,       encoding="utf-8"		) as csvfile:
  yield from csv.reader(_A		)





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		)      ->					Union[str, Any]:

 '''simple docstring'''






 snake_case__      							=			tmp_path / "cache"
 snake_case__      							=			os.path.join(_A		,       "tmp.csv"		)
 snake_case__      							=			CsvDatasetReader({"train": csv_path}		,       cache_dir=_A		).read()
 CsvDatasetWriter(dataset["train"]		,       _A		,       num_proc=1		).write()

 snake_case__      							=			iter_csv_file(_A		)
 snake_case__      							=			iter_csv_file(_A		)

 for rowa, rowa in zip(_A		,       _A		):
  assert rowa == rowa





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		)      ->					str:

 '''simple docstring'''






 snake_case__      							=			tmp_path / "cache"
 snake_case__      							=			os.path.join(_A		,       "tmp.csv"		)
 snake_case__      							=			CsvDatasetReader({"train": csv_path}		,       cache_dir=_A		).read()
 CsvDatasetWriter(dataset["train"]		,       _A		,       num_proc=2		).write()

 snake_case__      							=			iter_csv_file(_A		)
 snake_case__      							=			iter_csv_file(_A		)

 for rowa, rowa in zip(_A		,       _A		):
  assert rowa == rowa





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		)      ->					str:

 '''simple docstring'''






 snake_case__      							=			tmp_path / "cache"
 snake_case__      							=			os.path.join(_A		,       "tmp.csv"		)
 snake_case__      							=			CsvDatasetReader({"train": csv_path}		,       cache_dir=_A		).read()
 with pytest.raises(_A		):
  CsvDatasetWriter(dataset["train"]		,       _A		,       num_proc=0		)








"""simple docstring"""


from __future__ import annotations

from math import pi, pow





def 							a__     (					_UpperCAmelCase		)      ->					float:

 '''simple docstring'''






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





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		)      ->					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(_UpperCAmelCase		,       2		) * (3 * radius - height)





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		,       _UpperCAmelCase		)      ->					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(_UpperCAmelCase		,       _UpperCAmelCase		)		)

 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(_UpperCAmelCase		,       _UpperCAmelCase		) + vol_spherical_cap(_UpperCAmelCase		,       _UpperCAmelCase		)





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		,       _UpperCAmelCase		)      ->					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(_UpperCAmelCase		,       _UpperCAmelCase		)		)

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





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		,       _UpperCAmelCase		)      ->					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__     (					_UpperCAmelCase		,       _UpperCAmelCase		)      ->					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__     (					_UpperCAmelCase		,       _UpperCAmelCase		)      ->					float:

 '''simple docstring'''






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





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		)      ->					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__     (					_UpperCAmelCase		,       _UpperCAmelCase		)      ->					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__     (					_UpperCAmelCase		)      ->					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(_UpperCAmelCase		,       3		)





def 							a__     (					_UpperCAmelCase		)      ->					float:

 '''simple docstring'''






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





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		)      ->					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(_UpperCAmelCase		,       2		) * height * pi





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		,       _UpperCAmelCase		)      ->					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(_UpperCAmelCase		,       2		) - pow(_UpperCAmelCase		,       2		)) * height





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		,       _UpperCAmelCase		)      ->					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(_UpperCAmelCase		,       2		) + pow(_UpperCAmelCase		,       2		) + radius_a * radius_a)
 )





def 							a__     (					_UpperCAmelCase		,       _UpperCAmelCase		)      ->					float:

 '''simple docstring'''






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





def 							a__     (					)      ->					Union[str, Any]:

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

