code: 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 					__lowerCAmelCase			(  _A ,_A					):
  
  
  
  							"""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 					__lowerCAmelCase			(  _A ,_A ,_A					):
  
  
  
  							"""simple docstring"""
  
  
  							_lowercase				=	tmp_path / """cache"""
  							_lowercase				=	{"""col_1""": """int64""", """col_2""": """int64""", """col_3""": """float64"""}
  							with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
  														_lowercase				=	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 					__lowerCAmelCase			(  _A ,_A ,_A					):
  
  
  
  							"""simple docstring"""
  
  
  							_lowercase				=	tmp_path / """cache"""
  							# CSV file loses col_1 string dtype information: default now is "int64" instead of "string"
  							_lowercase				=	{"""col_1""": """int64""", """col_2""": """int64""", """col_3""": """float64"""}
  							_lowercase				=	features.copy() if features else default_expected_features
  							_lowercase				=	(
  							    Features({feature: Value(_A					) for feature, dtype in features.items()}					) if features is not None else None
  							)
  							_lowercase				=	CsvDatasetReader(_A ,features=_A ,cache_dir=_A					).read()
  							_check_csv_dataset(_A ,_A					)
  
  
  @pytest.mark.parametrize("""split""" ,[None, NamedSplit("""train"""					), """train""", """test"""]					)
  def 					__lowerCAmelCase			(  _A ,_A ,_A					):
  
  
  
  							"""simple docstring"""
  
  
  							_lowercase				=	tmp_path / """cache"""
  							_lowercase				=	{"""col_1""": """int64""", """col_2""": """int64""", """col_3""": """float64"""}
  							_lowercase				=	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 					__lowerCAmelCase			(  _A ,_A ,_A					):
  
  
  
  							"""simple docstring"""
  
  
  							if issubclass(_A ,_A					):
  														_lowercase				=	csv_path
  							elif issubclass(_A ,_A					):
  														_lowercase				=	[csv_path]
  							_lowercase				=	tmp_path / """cache"""
  							_lowercase				=	{"""col_1""": """int64""", """col_2""": """int64""", """col_3""": """float64"""}
  							_lowercase				=	CsvDatasetReader(_A ,cache_dir=_A					).read()
  							_check_csv_dataset(_A ,_A					)
  
  
  def 					__lowerCAmelCase			(  _A ,_A ,_A=("train",)					):
  
  
  
  							"""simple docstring"""
  
  
  							assert isinstance(_A ,_A					)
  							for split in splits:
  														_lowercase				=	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 					__lowerCAmelCase			(  _A ,_A ,_A					):
  
  
  
  							"""simple docstring"""
  
  
  							_lowercase				=	tmp_path / """cache"""
  							_lowercase				=	{"""col_1""": """int64""", """col_2""": """int64""", """col_3""": """float64"""}
  							with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
  														_lowercase				=	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 					__lowerCAmelCase			(  _A ,_A ,_A					):
  
  
  
  							"""simple docstring"""
  
  
  							_lowercase				=	tmp_path / """cache"""
  							# CSV file loses col_1 string dtype information: default now is "int64" instead of "string"
  							_lowercase				=	{"""col_1""": """int64""", """col_2""": """int64""", """col_3""": """float64"""}
  							_lowercase				=	features.copy() if features else default_expected_features
  							_lowercase				=	(
  							    Features({feature: Value(_A					) for feature, dtype in features.items()}					) if features is not None else None
  							)
  							_lowercase				=	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 					__lowerCAmelCase			(  _A ,_A ,_A					):
  
  
  
  							"""simple docstring"""
  
  
  							if split:
  														_lowercase				=	{split: csv_path}
  							else:
  														_lowercase				=	{"""train""": csv_path, """test""": csv_path}
  							_lowercase				=	tmp_path / """cache"""
  							_lowercase				=	{"""col_1""": """int64""", """col_2""": """int64""", """col_3""": """float64"""}
  							_lowercase				=	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 					__lowerCAmelCase			(  _A					):
  
  
  
  							"""simple docstring"""
  
  
  							with open(_A ,encoding="""utf-8"""					) as csvfile:
  														yield from csv.reader(_A					)
  
  
  def 					__lowerCAmelCase			(  _A ,_A					):
  
  
  
  							"""simple docstring"""
  
  
  							_lowercase				=	tmp_path / """cache"""
  							_lowercase				=	os.path.join(_A ,"""tmp.csv"""					)
  							_lowercase				=	CsvDatasetReader({"""train""": csv_path} ,cache_dir=_A					).read()
  							CsvDatasetWriter(dataset["""train"""] ,_A ,num_proc=1					).write()
  
  							_lowercase				=	iter_csv_file(_A					)
  							_lowercase				=	iter_csv_file(_A					)
  
  							for rowa, rowa in zip(_A ,_A					):
  														assert rowa == rowa
  
  
  def 					__lowerCAmelCase			(  _A ,_A					):
  
  
  
  							"""simple docstring"""
  
  
  							_lowercase				=	tmp_path / """cache"""
  							_lowercase				=	os.path.join(_A ,"""tmp.csv"""					)
  							_lowercase				=	CsvDatasetReader({"""train""": csv_path} ,cache_dir=_A					).read()
  							CsvDatasetWriter(dataset["""train"""] ,_A ,num_proc=2					).write()
  
  							_lowercase				=	iter_csv_file(_A					)
  							_lowercase				=	iter_csv_file(_A					)
  
  							for rowa, rowa in zip(_A ,_A					):
  														assert rowa == rowa
  
  
  
  
  
  
  
  def 					__lowerCAmelCase			(  _A ,_A					):
  
  
  
  							"""simple docstring"""
  
  
  							_lowercase				=	tmp_path / """cache"""
  							_lowercase				=	os.path.join(_A ,"""tmp.csv"""					)
  							_lowercase				=	CsvDatasetReader({"""train""": csv_path} ,cache_dir=_A					).read()
  							with pytest.raises(_A					):
  														CsvDatasetWriter(dataset["""train"""] ,_A ,num_proc=0					)
  
  
  
style_context: import math
  from timeit import timeit
  
  
  def 					__lowerCAmelCase			(  _A					):
  
  
  
  							"""simple docstring"""
  
  
  							_lowercase				=	0
  							_lowercase				=	abs(_A					)
  							while True:
  														_lowercase				=	n // 10
  														digits += 1
  														if n == 0:
  																					break
  							return digits
  
  
  def 					__lowerCAmelCase			(  _A					):
  
  
  
  							"""simple docstring"""
  
  
  							return 1 if n == 0 else math.floor(math.log(abs(_A					) ,10					) + 1					)
  
  
  def 					__lowerCAmelCase			(  _A					):
  
  
  
  							"""simple docstring"""
  
  
  							return len(str(abs(_A					)					)					)
  
  
  def 					__lowerCAmelCase			(  ):
  
  
  
  							"""simple docstring"""
  
  
  							from collections.abc import Callable
  
  							def benchmark_a_function(_A ,_A					) -> None:
  														_lowercase				=	f'''{func.__name__}({value})'''
  														_lowercase				=	timeit(f'''__main__.{call}''' ,setup="""import __main__"""					)
  														print(f'''{call}: {func(_A					)} -- {timing} seconds'''					)
  
  							for value in (262_144, 1_125_899_906_842_624, 1_267_650_600_228_229_401_496_703_205_376):
  														for func in (num_digits, num_digits_fast, num_digits_faster):
  																					benchmark_a_function(_A ,_A					)
  														print()
  
  
  if __name__ == "__main__":
  				import doctest
  
  				doctest.testmod()
  				benchmark()
  
  
  