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	(	__lowerCamelCase   ,       __lowerCamelCase					)   -> str:
  
       '''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	(	__lowerCamelCase   ,       __lowerCamelCase   ,       __lowerCamelCase					)   -> Optional[int]:
  
       '''simple docstring'''
       UpperCAmelCase__			:     Any										= tmp_path / """cache"""
       UpperCAmelCase__			:     Optional[Any]										= {"""col_1""": """int64""", """col_2""": """int64""", """col_3""": """float64"""}
       with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
            UpperCAmelCase__			:     List[Any]										= 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	(	__lowerCamelCase   ,       __lowerCamelCase   ,       __lowerCamelCase					)   -> List[str]:
  
       '''simple docstring'''
       UpperCAmelCase__			:     int										= tmp_path / """cache"""
       # CSV file loses col_1 string dtype information: default now is "int64" instead of "string"
       UpperCAmelCase__			:     List[str]										= {"""col_1""": """int64""", """col_2""": """int64""", """col_3""": """float64"""}
       UpperCAmelCase__			:     Any										= features.copy() if features else default_expected_features
       UpperCAmelCase__			:     str										= (
           Features({feature: Value(_A					) for feature, dtype in features.items()}					) if features is not None else None
       )
       UpperCAmelCase__			:     int										= CsvDatasetReader(_A   ,       features=_A   ,       cache_dir=_A					).read()
       _check_csv_dataset(_A   ,       _A					)
  
  
  
  
  
  @pytest.mark.parametrize("""split"""   ,       [None, NamedSplit("""train"""					), """train""", """test"""]					)
  def    _lowerCamelCase	(	__lowerCamelCase   ,       __lowerCamelCase   ,       __lowerCamelCase					)   -> Optional[Any]:
  
       '''simple docstring'''
       UpperCAmelCase__			:     Optional[int]										= tmp_path / """cache"""
       UpperCAmelCase__			:     List[Any]										= {"""col_1""": """int64""", """col_2""": """int64""", """col_3""": """float64"""}
       UpperCAmelCase__			:     Any										= 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	(	__lowerCamelCase   ,       __lowerCamelCase   ,       __lowerCamelCase					)   -> Union[str, Any]:
  
       '''simple docstring'''
  
  
       if issubclass(_A   ,       _A					):
            UpperCAmelCase__			:     str										= csv_path
       elif issubclass(_A   ,       _A					):
            UpperCAmelCase__			:     Tuple										= [csv_path]
       UpperCAmelCase__			:     List[str]										= tmp_path / """cache"""
       UpperCAmelCase__			:     Optional[int]										= {"""col_1""": """int64""", """col_2""": """int64""", """col_3""": """float64"""}
       UpperCAmelCase__			:     List[Any]										= CsvDatasetReader(_A   ,       cache_dir=_A					).read()
       _check_csv_dataset(_A   ,       _A					)
  
  
  
  
  
  def    _lowerCamelCase	(	__lowerCamelCase   ,       __lowerCamelCase   ,       __lowerCamelCase=("train",)					)   -> Tuple:
  
       '''simple docstring'''
       assert isinstance(_A   ,       _A					)
       for split in splits:
            UpperCAmelCase__			:     Union[str, Any]										= 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	(	__lowerCamelCase   ,       __lowerCamelCase   ,       __lowerCamelCase					)   -> str:
  
       '''simple docstring'''
       UpperCAmelCase__			:     Tuple										= tmp_path / """cache"""
       UpperCAmelCase__			:     Any										= {"""col_1""": """int64""", """col_2""": """int64""", """col_3""": """float64"""}
       with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
            UpperCAmelCase__			:     str										= 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	(	__lowerCamelCase   ,       __lowerCamelCase   ,       __lowerCamelCase					)   -> str:
  
       '''simple docstring'''
       UpperCAmelCase__			:     Any										= tmp_path / """cache"""
       # CSV file loses col_1 string dtype information: default now is "int64" instead of "string"
       UpperCAmelCase__			:     Optional[int]										= {"""col_1""": """int64""", """col_2""": """int64""", """col_3""": """float64"""}
       UpperCAmelCase__			:     Optional[Any]										= features.copy() if features else default_expected_features
       UpperCAmelCase__			:     Optional[Any]										= (
           Features({feature: Value(_A					) for feature, dtype in features.items()}					) if features is not None else None
       )
       UpperCAmelCase__			:     List[str]										= 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	(	__lowerCamelCase   ,       __lowerCamelCase   ,       __lowerCamelCase					)   -> int:
  
       '''simple docstring'''
  
  
       if split:
            UpperCAmelCase__			:     List[str]										= {split: csv_path}
       else:
            UpperCAmelCase__			:     str										= {"""train""": csv_path, """test""": csv_path}
       UpperCAmelCase__			:     List[Any]										= tmp_path / """cache"""
       UpperCAmelCase__			:     Optional[Any]										= {"""col_1""": """int64""", """col_2""": """int64""", """col_3""": """float64"""}
       UpperCAmelCase__			:     Optional[int]										= 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	(	__lowerCamelCase					)   -> Union[str, Any]:
  
       '''simple docstring'''
  
  
       with open(_A   ,       encoding="""utf-8"""					) as csvfile:
            yield from csv.reader(_A					)
  
  
  
  
  
  def    _lowerCamelCase	(	__lowerCamelCase   ,       __lowerCamelCase					)   -> str:
  
       '''simple docstring'''
       UpperCAmelCase__			:     Any										= tmp_path / """cache"""
       UpperCAmelCase__			:     Optional[int]										= os.path.join(_A   ,       """tmp.csv"""					)
       UpperCAmelCase__			:     Optional[Any]										= CsvDatasetReader({"""train""": csv_path}   ,       cache_dir=_A					).read()
       CsvDatasetWriter(dataset["""train"""]   ,       _A   ,       num_proc=1					).write()
  
       UpperCAmelCase__			:     int										= iter_csv_file(_A					)
       UpperCAmelCase__			:     Union[str, Any]										= iter_csv_file(_A					)
  
       for rowa, rowa in zip(_A   ,       _A					):
            assert rowa == rowa
  
  
  
  
  
  def    _lowerCamelCase	(	__lowerCamelCase   ,       __lowerCamelCase					)   -> List[str]:
  
       '''simple docstring'''
       UpperCAmelCase__			:     str										= tmp_path / """cache"""
       UpperCAmelCase__			:     Union[str, Any]										= os.path.join(_A   ,       """tmp.csv"""					)
       UpperCAmelCase__			:     Dict										= CsvDatasetReader({"""train""": csv_path}   ,       cache_dir=_A					).read()
       CsvDatasetWriter(dataset["""train"""]   ,       _A   ,       num_proc=2					).write()
  
       UpperCAmelCase__			:     Optional[Any]										= iter_csv_file(_A					)
       UpperCAmelCase__			:     List[Any]										= iter_csv_file(_A					)
  
       for rowa, rowa in zip(_A   ,       _A					):
            assert rowa == rowa
  
  
  
  
  
  
  
  def    _lowerCamelCase	(	__lowerCamelCase   ,       __lowerCamelCase					)   -> Dict:
  
       '''simple docstring'''
       UpperCAmelCase__			:     Optional[Any]										= tmp_path / """cache"""
       UpperCAmelCase__			:     int										= os.path.join(_A   ,       """tmp.csv"""					)
       UpperCAmelCase__			:     Any										= CsvDatasetReader({"""train""": csv_path}   ,       cache_dir=_A					).read()
       with pytest.raises(_A					):
            CsvDatasetWriter(dataset["""train"""]   ,       _A   ,       num_proc=0					)
  
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  
  import math
  import os
  
  import cva
  import numpy as np
  
  SCREAMING_SNAKE_CASE__		:       Optional[Any]   							=							255.0
  
  
  
  
  
  def    _lowerCamelCase	(	__lowerCamelCase   ,       __lowerCamelCase					)   -> float:
  
       '''simple docstring'''
       UpperCAmelCase__			:     List[Any]										= np.mean((original - contrast) ** 2					)
       if mse == 0:
            return 100
  
       return 20 * math.logaa(PIXEL_MAX / math.sqrt(__lowerCamelCase					)					)
  
  
  
  
  
  def    _lowerCamelCase	(	)   -> None:
  
       '''simple docstring'''
       UpperCAmelCase__			:     Union[str, Any]										= os.path.dirname(os.path.realpath(__lowerCamelCase					)					)
       # Loading images (original image and compressed image)
       UpperCAmelCase__			:     List[Any]										= cva.imread(os.path.join(__lowerCamelCase   ,       """image_data/original_image.png"""					)					)
       UpperCAmelCase__			:     Dict										= cva.imread(os.path.join(__lowerCamelCase   ,       """image_data/compressed_image.png"""					)   ,       1					)
  
       UpperCAmelCase__			:     Tuple										= cva.imread(os.path.join(__lowerCamelCase   ,       """image_data/PSNR-example-base.png"""					)					)
       UpperCAmelCase__			:     int										= cva.imread(
           os.path.join(__lowerCamelCase   ,       """image_data/PSNR-example-comp-10.jpg"""					)   ,       1					)
  
       # Value expected: 29.73dB
       print("""-- First Test --"""					)
       print(F"PSNR value is {peak_signal_to_noise_ratio(__lowerCamelCase   ,       __lowerCamelCase					)} dB"					)
  
       # # Value expected: 31.53dB (Wikipedia Example)
       print("""\n-- Second Test --"""					)
       print(F"PSNR value is {peak_signal_to_noise_ratio(__lowerCamelCase   ,       __lowerCamelCase					)} dB"					)
  
  
  if __name__ == "__main__":
        main()
  
  
  
  
  
  
  