Add files using upload-large-folder tool

.gitattributes

@@ -114,3 +114,5 @@ lib/python3.10/site-packages/av/filter/context.cpython-310-x86_64-linux-gnu.so f
 lib/python3.10/site-packages/av/filter/loudnorm.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 lib/python3.10/site-packages/av/subtitles/stream.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 lib/python3.10/site-packages/av/subtitles/subtitle.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+lib/python3.10/site-packages/av/attachments/stream.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+lib/python3.10/site-packages/av/codec/codec.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

lib/python3.10/site-packages/audioread-3.0.1.dist-info/INSTALLER

@@ -0,0 +1 @@
+uv

lib/python3.10/site-packages/av/attachments/stream.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:553f03e1929b382b3f750d81c000d626ac95fad1a09255e1d22dee6113c9e679
+size 338801

lib/python3.10/site-packages/av/codec/codec.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2cb8243da193ae6f4c48be60f2627606683549ee0df2f61548f6b93e0b372f32
+size 889001

lib/python3.10/site-packages/datasets/commands/__init__.py

@@ -0,0 +1,13 @@
+from abc import ABC, abstractmethod
+from argparse import ArgumentParser
+
+
+class BaseDatasetsCLICommand(ABC):
+    @staticmethod
+    @abstractmethod
+    def register_subcommand(parser: ArgumentParser):
+        raise NotImplementedError()
+
+    @abstractmethod
+    def run(self):
+        raise NotImplementedError()

lib/python3.10/site-packages/datasets/commands/convert.py

@@ -0,0 +1,195 @@
+import os
+import re
+import shutil
+from argparse import ArgumentParser, Namespace
+
+from datasets.commands import BaseDatasetsCLICommand
+from datasets.utils.logging import get_logger
+
+
+HIGHLIGHT_MESSAGE_PRE = """<<<<<<< This should probably be modified because it mentions: """
+
+HIGHLIGHT_MESSAGE_POST = """=======
+>>>>>>>
+"""
+
+TO_HIGHLIGHT = [
+    "TextEncoderConfig",
+    "ByteTextEncoder",
+    "SubwordTextEncoder",
+    "encoder_config",
+    "maybe_build_from_corpus",
+    "manual_dir",
+]
+
+TO_CONVERT = [
+    # (pattern, replacement)
+    # Order is important here for some replacements
+    (r"tfds\.core", r"datasets"),
+    (r"tf\.io\.gfile\.GFile", r"open"),
+    (r"tf\.([\w\d]+)", r"datasets.Value('\1')"),
+    (r"tfds\.features\.Text\(\)", r"datasets.Value('string')"),
+    (r"tfds\.features\.Text\(", r"datasets.Value('string'),"),
+    (r"features\s*=\s*tfds.features.FeaturesDict\(", r"features=datasets.Features("),
+    (r"tfds\.features\.FeaturesDict\(", r"dict("),
+    (r"The TensorFlow Datasets Authors", r"The TensorFlow Datasets Authors and the HuggingFace Datasets Authors"),
+    (r"tfds\.", r"datasets."),
+    (r"dl_manager\.manual_dir", r"self.config.data_dir"),
+    (r"self\.builder_config", r"self.config"),
+]
+
+
+def convert_command_factory(args: Namespace):
+    """
+    Factory function used to convert a model TF 1.0 checkpoint in a PyTorch checkpoint.
+
+    Returns: ConvertCommand
+    """
+    return ConvertCommand(args.tfds_path, args.datasets_directory)
+
+
+class ConvertCommand(BaseDatasetsCLICommand):
+    @staticmethod
+    def register_subcommand(parser: ArgumentParser):
+        """
+        Register this command to argparse so it's available for the datasets-cli
+
+        Args:
+            parser: Root parser to register command-specific arguments
+        """
+        train_parser = parser.add_parser(
+            "convert",
+            help="Convert a TensorFlow Datasets dataset to a HuggingFace Datasets dataset.",
+        )
+        train_parser.add_argument(
+            "--tfds_path",
+            type=str,
+            required=True,
+            help="Path to a TensorFlow Datasets folder to convert or a single tfds file to convert.",
+        )
+        train_parser.add_argument(
+            "--datasets_directory", type=str, required=True, help="Path to the HuggingFace Datasets folder."
+        )
+        train_parser.set_defaults(func=convert_command_factory)
+
+    def __init__(self, tfds_path: str, datasets_directory: str, *args):
+        self._logger = get_logger("datasets-cli/converting")
+
+        self._tfds_path = tfds_path
+        self._datasets_directory = datasets_directory
+
+    def run(self):
+        if os.path.isdir(self._tfds_path):
+            abs_tfds_path = os.path.abspath(self._tfds_path)
+        elif os.path.isfile(self._tfds_path):
+            abs_tfds_path = os.path.dirname(self._tfds_path)
+        else:
+            raise ValueError("--tfds_path is neither a directory nor a file. Please check path.")
+
+        abs_datasets_path = os.path.abspath(self._datasets_directory)
+
+        self._logger.info(f"Converting datasets from {abs_tfds_path} to {abs_datasets_path}")
+
+        utils_files = []
+        with_manual_update = []
+        imports_to_builder_map = {}
+
+        if os.path.isdir(self._tfds_path):
+            file_names = os.listdir(abs_tfds_path)
+        else:
+            file_names = [os.path.basename(self._tfds_path)]
+
+        for f_name in file_names:
+            self._logger.info(f"Looking at file {f_name}")
+            input_file = os.path.join(abs_tfds_path, f_name)
+            output_file = os.path.join(abs_datasets_path, f_name)
+
+            if not os.path.isfile(input_file) or "__init__" in f_name or "_test" in f_name or ".py" not in f_name:
+                self._logger.info("Skipping file")
+                continue
+
+            with open(input_file, encoding="utf-8") as f:
+                lines = f.readlines()
+
+            out_lines = []
+            is_builder = False
+            needs_manual_update = False
+            tfds_imports = []
+            for line in lines:
+                out_line = line
+
+                # Convert imports
+                if "import tensorflow.compat.v2 as tf" in out_line:
+                    continue
+                elif "@tfds.core" in out_line:
+                    continue
+                elif "builder=self" in out_line:
+                    continue
+                elif "import tensorflow_datasets.public_api as tfds" in out_line:
+                    out_line = "import datasets\n"
+                elif "import tensorflow" in out_line:
+                    # order is important here
+                    out_line = ""
+                    continue
+                elif "from absl import logging" in out_line:
+                    out_line = "from datasets import logging\n"
+                elif "getLogger" in out_line:
+                    out_line = out_line.replace("getLogger", "get_logger")
+                elif any(expression in out_line for expression in TO_HIGHLIGHT):
+                    needs_manual_update = True
+                    to_remove = list(filter(lambda e: e in out_line, TO_HIGHLIGHT))
+                    out_lines.append(HIGHLIGHT_MESSAGE_PRE + str(to_remove) + "\n")
+                    out_lines.append(out_line)
+                    out_lines.append(HIGHLIGHT_MESSAGE_POST)
+                    continue
+                else:
+                    for pattern, replacement in TO_CONVERT:
+                        out_line = re.sub(pattern, replacement, out_line)
+
+                # Take care of saving utilities (to later move them together with main script)
+                if "tensorflow_datasets" in out_line:
+                    match = re.match(r"from\stensorflow_datasets.*import\s([^\.\r\n]+)", out_line)
+                    tfds_imports.extend(imp.strip() for imp in match.group(1).split(","))
+                    out_line = "from . import " + match.group(1)
+
+                # Check we have not forget anything
+                if "tf." in out_line or "tfds." in out_line or "tensorflow_datasets" in out_line:
+                    raise ValueError(f"Error converting {out_line.strip()}")
+
+                if "GeneratorBasedBuilder" in out_line or "BeamBasedBuilder" in out_line:
+                    is_builder = True
+                out_lines.append(out_line)
+
+            if is_builder or "wmt" in f_name:
+                # We create a new directory for each dataset
+                dir_name = f_name.replace(".py", "")
+                output_dir = os.path.join(abs_datasets_path, dir_name)
+                output_file = os.path.join(output_dir, f_name)
+                os.makedirs(output_dir, exist_ok=True)
+                self._logger.info(f"Adding directory {output_dir}")
+                imports_to_builder_map.update({imp: output_dir for imp in tfds_imports})
+            else:
+                # Utilities will be moved at the end
+                utils_files.append(output_file)
+
+            if needs_manual_update:
+                with_manual_update.append(output_file)
+
+            with open(output_file, "w", encoding="utf-8") as f:
+                f.writelines(out_lines)
+            self._logger.info(f"Converted in {output_file}")
+
+        for utils_file in utils_files:
+            try:
+                f_name = os.path.basename(utils_file)
+                dest_folder = imports_to_builder_map[f_name.replace(".py", "")]
+                self._logger.info(f"Moving {dest_folder} to {utils_file}")
+                shutil.copy(utils_file, dest_folder)
+            except KeyError:
+                self._logger.error(f"Cannot find destination folder for {utils_file}. Please copy manually.")
+
+        if with_manual_update:
+            for file_path in with_manual_update:
+                self._logger.warning(
+                    f"You need to manually update file {file_path} to remove configurations using 'TextEncoderConfig'."
+                )

lib/python3.10/site-packages/datasets/commands/datasets_cli.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python
+from argparse import ArgumentParser
+
+from datasets.commands.convert import ConvertCommand
+from datasets.commands.dummy_data import DummyDataCommand
+from datasets.commands.env import EnvironmentCommand
+from datasets.commands.run_beam import RunBeamCommand
+from datasets.commands.test import TestCommand
+from datasets.utils.logging import set_verbosity_info
+
+
+def parse_unknown_args(unknown_args):
+    return {key.lstrip("-"): value for key, value in zip(unknown_args[::2], unknown_args[1::2])}
+
+
+def main():
+    parser = ArgumentParser(
+        "HuggingFace Datasets CLI tool", usage="datasets-cli <command> [<args>]", allow_abbrev=False
+    )
+    commands_parser = parser.add_subparsers(help="datasets-cli command helpers")
+    set_verbosity_info()
+
+    # Register commands
+    ConvertCommand.register_subcommand(commands_parser)
+    EnvironmentCommand.register_subcommand(commands_parser)
+    TestCommand.register_subcommand(commands_parser)
+    RunBeamCommand.register_subcommand(commands_parser)
+    DummyDataCommand.register_subcommand(commands_parser)
+
+    # Parse args
+    args, unknown_args = parser.parse_known_args()
+    if not hasattr(args, "func"):
+        parser.print_help()
+        exit(1)
+    kwargs = parse_unknown_args(unknown_args)
+
+    # Run
+    service = args.func(args, **kwargs)
+    service.run()
+
+
+if __name__ == "__main__":
+    main()

lib/python3.10/site-packages/datasets/commands/dummy_data.py

@@ -0,0 +1,468 @@
+import fnmatch
+import json
+import os
+import shutil
+import tempfile
+import xml.etree.ElementTree as ET
+from argparse import ArgumentParser
+from pathlib import Path
+from typing import Optional
+
+from datasets import config
+from datasets.commands import BaseDatasetsCLICommand
+from datasets.download.download_config import DownloadConfig
+from datasets.download.download_manager import DownloadManager
+from datasets.download.mock_download_manager import MockDownloadManager
+from datasets.load import dataset_module_factory, import_main_class
+from datasets.utils.deprecation_utils import deprecated
+from datasets.utils.logging import get_logger, set_verbosity_warning
+from datasets.utils.py_utils import map_nested
+
+
+logger = get_logger(__name__)
+
+DEFAULT_ENCODING = "utf-8"
+
+
+def dummy_data_command_factory(args):
+    return DummyDataCommand(
+        args.path_to_dataset,
+        args.auto_generate,
+        args.n_lines,
+        args.json_field,
+        args.xml_tag,
+        args.match_text_files,
+        args.keep_uncompressed,
+        args.cache_dir,
+        args.encoding,
+    )
+
+
+class DummyDataGeneratorDownloadManager(DownloadManager):
+    def __init__(self, mock_download_manager, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.mock_download_manager = mock_download_manager
+        self.downloaded_dummy_paths = []
+        self.expected_dummy_paths = []
+
+    def download(self, url_or_urls):
+        output = super().download(url_or_urls)
+        dummy_output = self.mock_download_manager.download(url_or_urls)
+        map_nested(self.downloaded_dummy_paths.append, output, map_tuple=True)
+        map_nested(self.expected_dummy_paths.append, dummy_output, map_tuple=True)
+        return output
+
+    def download_and_extract(self, url_or_urls):
+        output = super().extract(super().download(url_or_urls))
+        dummy_output = self.mock_download_manager.download(url_or_urls)
+        map_nested(self.downloaded_dummy_paths.append, output, map_tuple=True)
+        map_nested(self.expected_dummy_paths.append, dummy_output, map_tuple=True)
+        return output
+
+    def auto_generate_dummy_data_folder(
+        self,
+        n_lines: int = 5,
+        json_field: Optional[str] = None,
+        xml_tag: Optional[str] = None,
+        match_text_files: Optional[str] = None,
+        encoding: Optional[str] = None,
+    ) -> bool:
+        os.makedirs(
+            os.path.join(
+                self.mock_download_manager.datasets_scripts_dir,
+                self.mock_download_manager.dataset_name,
+                self.mock_download_manager.dummy_data_folder,
+                "dummy_data",
+            ),
+            exist_ok=True,
+        )
+        total = 0
+        self.mock_download_manager.load_existing_dummy_data = False
+        for src_path, relative_dst_path in zip(self.downloaded_dummy_paths, self.expected_dummy_paths):
+            dst_path = os.path.join(
+                self.mock_download_manager.datasets_scripts_dir,
+                self.mock_download_manager.dataset_name,
+                self.mock_download_manager.dummy_data_folder,
+                relative_dst_path,
+            )
+            total += self._create_dummy_data(
+                src_path,
+                dst_path,
+                n_lines=n_lines,
+                json_field=json_field,
+                xml_tag=xml_tag,
+                match_text_files=match_text_files,
+                encoding=encoding,
+            )
+        if total == 0:
+            logger.error(
+                "Dummy data generation failed: no dummy files were created. "
+                "Make sure the data files format is supported by the auto-generation."
+            )
+        return total > 0
+
+    def _create_dummy_data(
+        self,
+        src_path: str,
+        dst_path: str,
+        n_lines: int,
+        json_field: Optional[str] = None,
+        xml_tag: Optional[str] = None,
+        match_text_files: Optional[str] = None,
+        encoding: Optional[str] = None,
+    ) -> int:
+        encoding = encoding or DEFAULT_ENCODING
+        if os.path.isfile(src_path):
+            logger.debug(f"Trying to generate dummy data file {dst_path}")
+            dst_path_extensions = Path(dst_path).suffixes
+            line_by_line_extensions = [".txt", ".csv", ".jsonl", ".tsv"]
+            is_line_by_line_text_file = any(extension in dst_path_extensions for extension in line_by_line_extensions)
+            if match_text_files is not None:
+                file_name = os.path.basename(dst_path)
+                for pattern in match_text_files.split(","):
+                    is_line_by_line_text_file |= fnmatch.fnmatch(file_name, pattern)
+            # Line by line text file (txt, csv etc.)
+            if is_line_by_line_text_file:
+                Path(dst_path).parent.mkdir(exist_ok=True, parents=True)
+                with open(src_path, encoding=encoding) as src_file:
+                    with open(dst_path, "w", encoding=encoding) as dst_file:
+                        first_lines = []
+                        for i, line in enumerate(src_file):
+                            if i >= n_lines:
+                                break
+                            first_lines.append(line)
+                        dst_file.write("".join(first_lines).strip())
+                return 1
+            # json file
+            elif ".json" in dst_path_extensions:
+                with open(src_path, encoding=encoding) as src_file:
+                    json_data = json.load(src_file)
+                    if json_field is not None:
+                        json_data = json_data[json_field]
+                    if isinstance(json_data, dict):
+                        if not all(isinstance(v, list) for v in json_data.values()):
+                            raise ValueError(
+                                f"Couldn't parse columns {list(json_data.keys())}. "
+                                "Maybe specify which json field must be used "
+                                "to read the data with --json_field <my_field>."
+                            )
+                        first_json_data = {k: v[:n_lines] for k, v in json_data.items()}
+                    else:
+                        first_json_data = json_data[:n_lines]
+                    if json_field is not None:
+                        first_json_data = {json_field: first_json_data}
+                    Path(dst_path).parent.mkdir(exist_ok=True, parents=True)
+                    with open(dst_path, "w", encoding=encoding) as dst_file:
+                        json.dump(first_json_data, dst_file)
+                return 1
+            # xml file
+            elif any(extension in dst_path_extensions for extension in [".xml", ".txm"]):
+                if xml_tag is None:
+                    logger.warning("Found xml file but 'xml_tag' is set to None. Please provide --xml_tag")
+                else:
+                    self._create_xml_dummy_data(src_path, dst_path, xml_tag, n_lines=n_lines, encoding=encoding)
+                return 1
+            logger.warning(
+                f"Couldn't generate dummy file '{dst_path}'. " "Ignore that if this file is not useful for dummy data."
+            )
+            return 0
+        # directory, iterate through all files
+        elif os.path.isdir(src_path):
+            total = 0
+            for path, _, files in os.walk(src_path):
+                for name in files:
+                    if not name.startswith("."):  # ignore files like .DS_Store etc.
+                        src_file_path = os.path.join(path, name)
+                        dst_file_path = os.path.join(dst_path, Path(src_file_path).relative_to(src_path))
+                        total += self._create_dummy_data(
+                            src_file_path,
+                            dst_file_path,
+                            n_lines=n_lines,
+                            json_field=json_field,
+                            xml_tag=xml_tag,
+                            match_text_files=match_text_files,
+                            encoding=encoding,
+                        )
+            return total
+
+    @staticmethod
+    def _create_xml_dummy_data(src_path, dst_path, xml_tag, n_lines=5, encoding=DEFAULT_ENCODING):
+        Path(dst_path).parent.mkdir(exist_ok=True, parents=True)
+        with open(src_path, encoding=encoding) as src_file:
+            n_line = 0
+            parents = []
+            for event, elem in ET.iterparse(src_file, events=("start", "end")):
+                if event == "start":
+                    parents.append(elem)
+                else:
+                    _ = parents.pop()
+                    if elem.tag == xml_tag:
+                        if n_line < n_lines:
+                            n_line += 1
+                        else:
+                            if parents:
+                                parents[-1].remove(elem)
+            ET.ElementTree(element=elem).write(dst_path, encoding=encoding)
+
+    def compress_autogenerated_dummy_data(self, path_to_dataset):
+        root_dir = os.path.join(path_to_dataset, self.mock_download_manager.dummy_data_folder)
+        base_name = os.path.join(root_dir, "dummy_data")
+        base_dir = "dummy_data"
+        logger.info(f"Compressing dummy data folder to '{base_name}.zip'")
+        shutil.make_archive(base_name, "zip", root_dir, base_dir)
+        shutil.rmtree(base_name)
+
+
+@deprecated(
+    "The `datasets` repository does not host the dataset scripts anymore. Therefore, dummy data is no longer needed to test their loading with CI."
+)
+class DummyDataCommand(BaseDatasetsCLICommand):
+    @staticmethod
+    def register_subcommand(parser: ArgumentParser):
+        test_parser = parser.add_parser("dummy_data", help="Generate dummy data.")
+        test_parser.add_argument("--auto_generate", action="store_true", help="Automatically generate dummy data")
+        test_parser.add_argument(
+            "--n_lines", type=int, default=5, help="Number of lines or samples to keep when auto-generating dummy data"
+        )
+        test_parser.add_argument(
+            "--json_field",
+            type=str,
+            default=None,
+            help="Optional, json field to read the data from when auto-generating dummy data. In the json data files, this field must point to a list of samples as json objects (ex: the 'data' field for squad-like files)",
+        )
+        test_parser.add_argument(
+            "--xml_tag",
+            type=str,
+            default=None,
+            help="Optional, xml tag name of the samples inside the xml files when auto-generating dummy data.",
+        )
+        test_parser.add_argument(
+            "--match_text_files",
+            type=str,
+            default=None,
+            help="Optional, a comma separated list of file patterns that looks for line-by-line text files other than *.txt or *.csv. Example: --match_text_files *.label",
+        )
+        test_parser.add_argument(
+            "--keep_uncompressed",
+            action="store_true",
+            help="Whether to leave the dummy data folders uncompressed when auto-generating dummy data. Useful for debugging for to do manual adjustements before compressing.",
+        )
+        test_parser.add_argument(
+            "--cache_dir",
+            type=str,
+            default=None,
+            help="Cache directory to download and cache files when auto-generating dummy data",
+        )
+        test_parser.add_argument(
+            "--encoding",
+            type=str,
+            default=None,
+            help=f"Encoding to use when auto-generating dummy data. Defaults to {DEFAULT_ENCODING}",
+        )
+        test_parser.add_argument("path_to_dataset", type=str, help="Path to the dataset (example: ./datasets/squad)")
+        test_parser.set_defaults(func=dummy_data_command_factory)
+
+    def __init__(
+        self,
+        path_to_dataset: str,
+        auto_generate: bool,
+        n_lines: int,
+        json_field: Optional[str],
+        xml_tag: Optional[str],
+        match_text_files: Optional[str],
+        keep_uncompressed: bool,
+        cache_dir: Optional[str],
+        encoding: Optional[str],
+    ):
+        self._path_to_dataset = path_to_dataset
+        if os.path.isdir(path_to_dataset):
+            self._dataset_name = path_to_dataset.replace(os.sep, "/").split("/")[-1]
+        else:
+            self._dataset_name = path_to_dataset.replace(os.sep, "/").split("/")[-2]
+        cache_dir = os.path.expanduser(cache_dir or config.HF_DATASETS_CACHE)
+        self._auto_generate = auto_generate
+        self._n_lines = n_lines
+        self._json_field = json_field
+        self._xml_tag = xml_tag
+        self._match_text_files = match_text_files
+        self._keep_uncompressed = keep_uncompressed
+        self._cache_dir = cache_dir
+        self._encoding = encoding
+
+    def run(self):
+        set_verbosity_warning()
+        dataset_module = dataset_module_factory(self._path_to_dataset)
+        builder_cls = import_main_class(dataset_module.module_path)
+
+        # use `None` as config if no configs
+        builder_configs = builder_cls.BUILDER_CONFIGS or [None]
+        auto_generate_results = []
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            for builder_config in builder_configs:
+                config_name = builder_config.name if builder_config else None
+                dataset_builder = builder_cls(config_name=config_name, hash=dataset_module.hash, cache_dir=tmp_dir)
+                version = builder_config.version if builder_config else dataset_builder.config.version
+                mock_dl_manager = MockDownloadManager(
+                    dataset_name=self._dataset_name,
+                    config=builder_config,
+                    version=version,
+                    use_local_dummy_data=True,
+                    load_existing_dummy_data=False,
+                )
+
+                if self._auto_generate:
+                    auto_generate_results.append(
+                        self._autogenerate_dummy_data(
+                            dataset_builder=dataset_builder,
+                            mock_dl_manager=mock_dl_manager,
+                            keep_uncompressed=self._keep_uncompressed,
+                        )
+                    )
+                else:
+                    self._print_dummy_data_instructions(
+                        dataset_builder=dataset_builder, mock_dl_manager=mock_dl_manager
+                    )
+            if self._auto_generate and not self._keep_uncompressed:
+                if all(auto_generate_results):
+                    print(f"Automatic dummy data generation succeeded for all configs of '{self._path_to_dataset}'")
+                else:
+                    print(f"Automatic dummy data generation failed for some configs of '{self._path_to_dataset}'")
+
+    def _autogenerate_dummy_data(self, dataset_builder, mock_dl_manager, keep_uncompressed) -> Optional[bool]:
+        dl_cache_dir = (
+            os.path.join(self._cache_dir, config.DOWNLOADED_DATASETS_DIR)
+            if self._cache_dir
+            else config.DOWNLOADED_DATASETS_PATH
+        )
+        download_config = DownloadConfig(cache_dir=dl_cache_dir)
+        dl_manager = DummyDataGeneratorDownloadManager(
+            dataset_name=self._dataset_name, mock_download_manager=mock_dl_manager, download_config=download_config
+        )
+        dataset_builder._split_generators(dl_manager)
+        mock_dl_manager.load_existing_dummy_data = False  # don't use real dummy data
+        dl_manager.auto_generate_dummy_data_folder(
+            n_lines=self._n_lines,
+            json_field=self._json_field,
+            xml_tag=self._xml_tag,
+            match_text_files=self._match_text_files,
+            encoding=self._encoding,
+        )
+        if not keep_uncompressed:
+            path_do_dataset = os.path.join(mock_dl_manager.datasets_scripts_dir, mock_dl_manager.dataset_name)
+            dl_manager.compress_autogenerated_dummy_data(path_do_dataset)
+            # now test that the dummy_data.zip file actually works
+            mock_dl_manager.load_existing_dummy_data = True  # use real dummy data
+            n_examples_per_split = {}
+            os.makedirs(dataset_builder._cache_dir, exist_ok=True)
+            try:
+                split_generators = dataset_builder._split_generators(mock_dl_manager)
+                for split_generator in split_generators:
+                    dataset_builder._prepare_split(split_generator, check_duplicate_keys=False)
+                    n_examples_per_split[split_generator.name] = split_generator.split_info.num_examples
+            except OSError as e:
+                logger.error(
+                    f"Failed to load dummy data for config '{dataset_builder.config.name}''.\nOriginal error:\n"
+                    + str(e)
+                )
+                return False
+            else:
+                if all(n_examples > 0 for n_examples in n_examples_per_split.values()):
+                    logger.warning(
+                        f"Dummy data generation done and dummy data test succeeded for config '{dataset_builder.config.name}''."
+                    )
+                    return True
+                else:
+                    empty_splits = [
+                        split_name for split_name in n_examples_per_split if n_examples_per_split[split_name] == 0
+                    ]
+                    logger.warning(
+                        f"Dummy data generation done but dummy data test failed since splits {empty_splits} have 0 examples for config '{dataset_builder.config.name}''."
+                    )
+                    return False
+        else:
+            generated_dummy_data_dir = os.path.join(self._path_to_dataset, mock_dl_manager.dummy_data_folder)
+            logger.info(
+                f"Dummy data generated in directory '{generated_dummy_data_dir}' but kept uncompressed. "
+                "Please compress this directory into a zip file to use it for dummy data tests."
+            )
+
+    def _print_dummy_data_instructions(self, dataset_builder, mock_dl_manager):
+        dummy_data_folder = os.path.join(self._path_to_dataset, mock_dl_manager.dummy_data_folder)
+        logger.info(f"Creating dummy folder structure for {dummy_data_folder}... ")
+        os.makedirs(dummy_data_folder, exist_ok=True)
+
+        try:
+            generator_splits = dataset_builder._split_generators(mock_dl_manager)
+        except FileNotFoundError as e:
+            print(
+                f"Dataset {self._dataset_name} with config {mock_dl_manager.config} seems to already open files in the method `_split_generators(...)`. You might consider to instead only open files in the method `_generate_examples(...)` instead. If this is not possible the dummy data has to be created with less guidance. Make sure you create the file {e.filename}."
+            )
+
+        files_to_create = set()
+        split_names = []
+        dummy_file_name = mock_dl_manager.dummy_file_name
+
+        for split in generator_splits:
+            logger.info(f"Collecting dummy data file paths to create for {split.name}")
+            split_names.append(split.name)
+            gen_kwargs = split.gen_kwargs
+            generator = dataset_builder._generate_examples(**gen_kwargs)
+
+            try:
+                dummy_data_guidance_print = "\n" + 30 * "=" + "DUMMY DATA INSTRUCTIONS" + 30 * "=" + "\n"
+                config_string = (
+                    f"config {mock_dl_manager.config.name} of " if mock_dl_manager.config is not None else ""
+                )
+                dummy_data_guidance_print += (
+                    "- In order to create the dummy data for "
+                    + config_string
+                    + f"{self._dataset_name}, please go into the folder '{dummy_data_folder}' with `cd {dummy_data_folder}` . \n\n"
+                )
+
+                # trigger generate function
+                for key, record in generator:
+                    pass
+
+                dummy_data_guidance_print += f"- It appears that the function `_generate_examples(...)` expects one or more files in the folder {dummy_file_name} using the function `glob.glob(...)`. In this case, please refer to the `_generate_examples(...)` method to see under which filename the dummy data files should be created. \n\n"
+
+            except FileNotFoundError as e:
+                files_to_create.add(e.filename)
+
+        split_names = ", ".join(split_names)
+        if len(files_to_create) > 0:
+            # no glob.glob(...) in `_generate_examples(...)`
+            if len(files_to_create) == 1 and next(iter(files_to_create)) == dummy_file_name:
+                dummy_data_guidance_print += f"- Please create a single dummy data file called '{next(iter(files_to_create))}' from the folder '{dummy_data_folder}'. Make sure that the dummy data file provides at least one example for the split(s) '{split_names}' \n\n"
+                files_string = dummy_file_name
+            else:
+                files_string = ", ".join(files_to_create)
+                dummy_data_guidance_print += f"- Please create the following dummy data files '{files_string}' from the folder '{dummy_data_folder}'\n\n"
+
+                dummy_data_guidance_print += f"- For each of the splits '{split_names}', make sure that one or more of the dummy data files provide at least one example \n\n"
+
+            dummy_data_guidance_print += f"- If the method `_generate_examples(...)` includes multiple `open()` statements, you might have to create other files in addition to '{files_string}'. In this case please refer to the `_generate_examples(...)` method \n\n"
+
+        if len(files_to_create) == 1 and next(iter(files_to_create)) == dummy_file_name:
+            dummy_data_guidance_print += f"- After the dummy data file is created, it should be zipped to '{dummy_file_name}.zip' with the command `zip {dummy_file_name}.zip {dummy_file_name}` \n\n"
+
+            dummy_data_guidance_print += (
+                f"- You can now delete the file '{dummy_file_name}' with the command `rm {dummy_file_name}` \n\n"
+            )
+
+            dummy_data_guidance_print += f"- To get the file '{dummy_file_name}' back for further changes to the dummy data, simply unzip {dummy_file_name}.zip with the command `unzip {dummy_file_name}.zip` \n\n"
+        else:
+            dummy_data_guidance_print += f"- After all dummy data files are created, they should be zipped recursively to '{dummy_file_name}.zip' with the command `zip -r {dummy_file_name}.zip {dummy_file_name}/` \n\n"
+
+            dummy_data_guidance_print += (
+                f"- You can now delete the folder '{dummy_file_name}' with the command `rm -r {dummy_file_name}` \n\n"
+            )
+
+            dummy_data_guidance_print += f"- To get the folder '{dummy_file_name}' back for further changes to the dummy data, simply unzip {dummy_file_name}.zip with the command `unzip {dummy_file_name}.zip` \n\n"
+
+        dummy_data_guidance_print += (
+            f"- Make sure you have created the file '{dummy_file_name}.zip' in '{dummy_data_folder}' \n"
+        )
+
+        dummy_data_guidance_print += 83 * "=" + "\n"
+
+        print(dummy_data_guidance_print)

lib/python3.10/site-packages/datasets/commands/env.py

@@ -0,0 +1,39 @@
+import platform
+from argparse import ArgumentParser
+
+import huggingface_hub
+import pandas
+import pyarrow
+
+from datasets import __version__ as version
+from datasets.commands import BaseDatasetsCLICommand
+
+
+def info_command_factory(_):
+    return EnvironmentCommand()
+
+
+class EnvironmentCommand(BaseDatasetsCLICommand):
+    @staticmethod
+    def register_subcommand(parser: ArgumentParser):
+        download_parser = parser.add_parser("env", help="Print relevant system environment info.")
+        download_parser.set_defaults(func=info_command_factory)
+
+    def run(self):
+        info = {
+            "`datasets` version": version,
+            "Platform": platform.platform(),
+            "Python version": platform.python_version(),
+            "Huggingface_hub version": huggingface_hub.__version__,
+            "PyArrow version": pyarrow.__version__,
+            "Pandas version": pandas.__version__,
+        }
+
+        print("\nCopy-and-paste the text below in your GitHub issue.\n")
+        print(self.format_dict(info))
+
+        return info
+
+    @staticmethod
+    def format_dict(d):
+        return "\n".join([f"- {prop}: {val}" for prop, val in d.items()]) + "\n"

lib/python3.10/site-packages/datasets/commands/run_beam.py

@@ -0,0 +1,165 @@
+import os
+from argparse import ArgumentParser
+from pathlib import Path
+from shutil import copyfile
+from typing import List
+
+from datasets import config
+from datasets.builder import DatasetBuilder
+from datasets.commands import BaseDatasetsCLICommand
+from datasets.download.download_config import DownloadConfig
+from datasets.download.download_manager import DownloadMode
+from datasets.load import dataset_module_factory, import_main_class
+from datasets.utils.info_utils import VerificationMode
+
+
+def run_beam_command_factory(args, **kwargs):
+    return RunBeamCommand(
+        args.dataset,
+        args.name,
+        args.cache_dir,
+        args.beam_pipeline_options,
+        args.data_dir,
+        args.all_configs,
+        args.save_info or args.save_infos,
+        args.ignore_verifications,
+        args.force_redownload,
+        **kwargs,
+    )
+
+
+class RunBeamCommand(BaseDatasetsCLICommand):
+    @staticmethod
+    def register_subcommand(parser: ArgumentParser):
+        run_beam_parser = parser.add_parser("run_beam", help="Run a Beam dataset processing pipeline")
+        run_beam_parser.add_argument("dataset", type=str, help="Name of the dataset to download")
+        run_beam_parser.add_argument("--name", type=str, default=None, help="Dataset config name")
+        run_beam_parser.add_argument(
+            "--cache_dir",
+            type=str,
+            default=None,
+            help="Cache directory where the datasets are stored",
+        )
+        run_beam_parser.add_argument(
+            "--beam_pipeline_options",
+            type=str,
+            default="",
+            help="Beam pipeline options, separated by commas. Example:: `--beam_pipeline_options=job_name=my-job,project=my-project`",
+        )
+        run_beam_parser.add_argument(
+            "--data_dir",
+            type=str,
+            default=None,
+            help="Can be used to specify a manual directory to get the files from",
+        )
+        run_beam_parser.add_argument("--all_configs", action="store_true", help="Test all dataset configurations")
+        run_beam_parser.add_argument("--save_info", action="store_true", help="Save the dataset infos file")
+        run_beam_parser.add_argument(
+            "--ignore_verifications", action="store_true", help="Run the test without checksums and splits checks"
+        )
+        run_beam_parser.add_argument("--force_redownload", action="store_true", help="Force dataset redownload")
+        # aliases
+        run_beam_parser.add_argument("--save_infos", action="store_true", help="alias for save_info")
+        run_beam_parser.set_defaults(func=run_beam_command_factory)
+
+    def __init__(
+        self,
+        dataset: str,
+        name: str,
+        cache_dir: str,
+        beam_pipeline_options: str,
+        data_dir: str,
+        all_configs: bool,
+        save_infos: bool,
+        ignore_verifications: bool,
+        force_redownload: bool,
+        **config_kwargs,
+    ):
+        self._dataset = dataset
+        self._name = name
+        self._cache_dir = cache_dir
+        self._beam_pipeline_options = beam_pipeline_options
+        self._data_dir = data_dir
+        self._all_configs = all_configs
+        self._save_infos = save_infos
+        self._ignore_verifications = ignore_verifications
+        self._force_redownload = force_redownload
+        self._config_kwargs = config_kwargs
+
+    def run(self):
+        import apache_beam as beam
+
+        if self._name is not None and self._all_configs:
+            print("Both parameters `name` and `all_configs` can't be used at once.")
+            exit(1)
+        path, config_name = self._dataset, self._name
+        dataset_module = dataset_module_factory(path)
+        builder_cls = import_main_class(dataset_module.module_path)
+        builders: List[DatasetBuilder] = []
+        if self._beam_pipeline_options:
+            beam_options = beam.options.pipeline_options.PipelineOptions(
+                flags=[f"--{opt.strip()}" for opt in self._beam_pipeline_options.split(",") if opt]
+            )
+        else:
+            beam_options = None
+        if self._all_configs and len(builder_cls.BUILDER_CONFIGS) > 0:
+            for builder_config in builder_cls.BUILDER_CONFIGS:
+                builders.append(
+                    builder_cls(
+                        config_name=builder_config.name,
+                        data_dir=self._data_dir,
+                        hash=dataset_module.hash,
+                        beam_options=beam_options,
+                        cache_dir=self._cache_dir,
+                        base_path=dataset_module.builder_kwargs.get("base_path"),
+                    )
+                )
+        else:
+            builders.append(
+                builder_cls(
+                    config_name=config_name,
+                    data_dir=self._data_dir,
+                    beam_options=beam_options,
+                    cache_dir=self._cache_dir,
+                    base_path=dataset_module.builder_kwargs.get("base_path"),
+                    **self._config_kwargs,
+                )
+            )
+
+        for builder in builders:
+            builder.download_and_prepare(
+                download_mode=DownloadMode.REUSE_CACHE_IF_EXISTS
+                if not self._force_redownload
+                else DownloadMode.FORCE_REDOWNLOAD,
+                download_config=DownloadConfig(cache_dir=config.DOWNLOADED_DATASETS_PATH),
+                verification_mode=VerificationMode.NO_CHECKS
+                if self._ignore_verifications
+                else VerificationMode.ALL_CHECKS,
+                try_from_hf_gcs=False,
+            )
+            if self._save_infos:
+                builder._save_infos()
+
+        print("Apache beam run successful.")
+
+        # If save_infos=True, the dataset infos file is created next to the loaded module file.
+        # Let's move it to the original directory of the dataset script, to allow the user to
+        # upload them on S3 at the same time afterwards.
+        if self._save_infos:
+            dataset_infos_path = os.path.join(builder_cls.get_imported_module_dir(), config.DATASETDICT_INFOS_FILENAME)
+
+            name = Path(path).name + ".py"
+
+            combined_path = os.path.join(path, name)
+            if os.path.isfile(path):
+                dataset_dir = os.path.dirname(path)
+            elif os.path.isfile(combined_path):
+                dataset_dir = path
+            else:  # in case of a remote dataset
+                print(f"Dataset Infos file saved at {dataset_infos_path}")
+                exit(1)
+
+            # Move datasetinfo back to the user
+            user_dataset_infos_path = os.path.join(dataset_dir, config.DATASETDICT_INFOS_FILENAME)
+            copyfile(dataset_infos_path, user_dataset_infos_path)
+            print(f"Dataset Infos file saved at {user_dataset_infos_path}")

lib/python3.10/site-packages/datasets/commands/test.py

@@ -0,0 +1,194 @@
+import os
+from argparse import ArgumentParser
+from pathlib import Path
+from shutil import copyfile, rmtree
+from typing import Generator
+
+import datasets.config
+from datasets.builder import DatasetBuilder
+from datasets.commands import BaseDatasetsCLICommand
+from datasets.download.download_manager import DownloadMode
+from datasets.load import dataset_module_factory, import_main_class
+from datasets.utils.filelock import logger as fl_logger
+from datasets.utils.info_utils import VerificationMode
+from datasets.utils.logging import ERROR, get_logger
+
+
+logger = get_logger(__name__)
+
+
+def _test_command_factory(args):
+    return TestCommand(
+        args.dataset,
+        args.name,
+        args.cache_dir,
+        args.data_dir,
+        args.all_configs,
+        args.save_info or args.save_infos,
+        args.ignore_verifications,
+        args.force_redownload,
+        args.clear_cache,
+    )
+
+
+class TestCommand(BaseDatasetsCLICommand):
+    __test__ = False  # to tell pytest it's not a test class
+
+    @staticmethod
+    def register_subcommand(parser: ArgumentParser):
+        test_parser = parser.add_parser("test", help="Test dataset implementation.")
+        test_parser.add_argument("--name", type=str, default=None, help="Dataset processing name")
+        test_parser.add_argument(
+            "--cache_dir",
+            type=str,
+            default=None,
+            help="Cache directory where the datasets are stored.",
+        )
+        test_parser.add_argument(
+            "--data_dir",
+            type=str,
+            default=None,
+            help="Can be used to specify a manual directory to get the files from.",
+        )
+        test_parser.add_argument("--all_configs", action="store_true", help="Test all dataset configurations")
+        test_parser.add_argument(
+            "--save_info", action="store_true", help="Save the dataset infos in the dataset card (README.md)"
+        )
+        test_parser.add_argument(
+            "--ignore_verifications",
+            action="store_true",
+            help="Run the test without checksums and splits checks.",
+        )
+        test_parser.add_argument("--force_redownload", action="store_true", help="Force dataset redownload")
+        test_parser.add_argument(
+            "--clear_cache",
+            action="store_true",
+            help="Remove downloaded files and cached datasets after each config test",
+        )
+        # aliases
+        test_parser.add_argument("--save_infos", action="store_true", help="alias to save_info")
+        test_parser.add_argument("dataset", type=str, help="Name of the dataset to download")
+        test_parser.set_defaults(func=_test_command_factory)
+
+    def __init__(
+        self,
+        dataset: str,
+        name: str,
+        cache_dir: str,
+        data_dir: str,
+        all_configs: bool,
+        save_infos: bool,
+        ignore_verifications: bool,
+        force_redownload: bool,
+        clear_cache: bool,
+    ):
+        self._dataset = dataset
+        self._name = name
+        self._cache_dir = cache_dir
+        self._data_dir = data_dir
+        self._all_configs = all_configs
+        self._save_infos = save_infos
+        self._ignore_verifications = ignore_verifications
+        self._force_redownload = force_redownload
+        self._clear_cache = clear_cache
+        if clear_cache and not cache_dir:
+            print(
+                "When --clear_cache is used, specifying a cache directory is mandatory.\n"
+                "The 'download' folder of the cache directory and the dataset builder cache will be deleted after each configuration test.\n"
+                "Please provide a --cache_dir that will be used to test the dataset script."
+            )
+            exit(1)
+        if save_infos:
+            self._ignore_verifications = True
+
+    def run(self):
+        fl_logger().setLevel(ERROR)
+        if self._name is not None and self._all_configs:
+            print("Both parameters `config` and `all_configs` can't be used at once.")
+            exit(1)
+        path, config_name = self._dataset, self._name
+        module = dataset_module_factory(path)
+        builder_cls = import_main_class(module.module_path)
+        n_builders = len(builder_cls.BUILDER_CONFIGS) if self._all_configs and builder_cls.BUILDER_CONFIGS else 1
+
+        def get_builders() -> Generator[DatasetBuilder, None, None]:
+            if self._all_configs and builder_cls.BUILDER_CONFIGS:
+                for i, config in enumerate(builder_cls.BUILDER_CONFIGS):
+                    if "config_name" in module.builder_kwargs:
+                        yield builder_cls(
+                            cache_dir=self._cache_dir,
+                            data_dir=self._data_dir,
+                            **module.builder_kwargs,
+                        )
+                    else:
+                        yield builder_cls(
+                            config_name=config.name,
+                            cache_dir=self._cache_dir,
+                            data_dir=self._data_dir,
+                            **module.builder_kwargs,
+                        )
+            else:
+                if "config_name" in module.builder_kwargs:
+                    yield builder_cls(cache_dir=self._cache_dir, data_dir=self._data_dir, **module.builder_kwargs)
+                else:
+                    yield builder_cls(
+                        config_name=config_name,
+                        cache_dir=self._cache_dir,
+                        data_dir=self._data_dir,
+                        **module.builder_kwargs,
+                    )
+
+        for j, builder in enumerate(get_builders()):
+            print(f"Testing builder '{builder.config.name}' ({j + 1}/{n_builders})")
+            builder._record_infos = os.path.exists(
+                os.path.join(builder.get_imported_module_dir(), datasets.config.DATASETDICT_INFOS_FILENAME)
+            )  # record checksums only if we need to update a (deprecated) dataset_infos.json
+            builder.download_and_prepare(
+                download_mode=DownloadMode.REUSE_CACHE_IF_EXISTS
+                if not self._force_redownload
+                else DownloadMode.FORCE_REDOWNLOAD,
+                verification_mode=VerificationMode.NO_CHECKS
+                if self._ignore_verifications
+                else VerificationMode.ALL_CHECKS,
+                try_from_hf_gcs=False,
+            )
+            builder.as_dataset()
+            if self._save_infos:
+                builder._save_infos()
+
+            # If save_infos=True, the dataset card (README.md) is created next to the loaded module file.
+            # The dataset_infos are saved in the YAML part of the README.md
+
+            # Let's move it to the original directory of the dataset script, to allow the user to
+            # upload them on S3 at the same time afterwards.
+            if self._save_infos:
+                dataset_readme_path = os.path.join(builder_cls.get_imported_module_dir(), "README.md")
+                name = Path(path).name + ".py"
+                combined_path = os.path.join(path, name)
+                if os.path.isfile(path):
+                    dataset_dir = os.path.dirname(path)
+                elif os.path.isfile(combined_path):
+                    dataset_dir = path
+                elif os.path.isdir(path):  # for local directories containing only data files
+                    dataset_dir = path
+                else:  # in case of a remote dataset
+                    dataset_dir = None
+                    print(f"Dataset card saved at {dataset_readme_path}")
+
+                # Move dataset_info back to the user
+                if dataset_dir is not None:
+                    user_dataset_readme_path = os.path.join(dataset_dir, "README.md")
+                    copyfile(dataset_readme_path, user_dataset_readme_path)
+                    print(f"Dataset card saved at {user_dataset_readme_path}")
+
+            # If clear_cache=True, the download folder and the dataset builder cache directory are deleted
+            if self._clear_cache:
+                if os.path.isdir(builder._cache_dir):
+                    logger.warning(f"Clearing cache at {builder._cache_dir}")
+                    rmtree(builder._cache_dir)
+                download_dir = os.path.join(self._cache_dir, datasets.config.DOWNLOADED_DATASETS_DIR)
+                if os.path.isdir(download_dir):
+                    logger.warning(f"Clearing cache at {download_dir}")
+                    rmtree(download_dir)
+
+        print("Test successful.")

lib/python3.10/site-packages/datasets/io/abc.py

@@ -0,0 +1,53 @@
+from abc import ABC, abstractmethod
+from typing import Optional, Union
+
+from .. import Dataset, DatasetDict, Features, IterableDataset, IterableDatasetDict, NamedSplit
+from ..utils.typing import NestedDataStructureLike, PathLike
+
+
+class AbstractDatasetReader(ABC):
+    def __init__(
+        self,
+        path_or_paths: Optional[NestedDataStructureLike[PathLike]] = None,
+        split: Optional[NamedSplit] = None,
+        features: Optional[Features] = None,
+        cache_dir: str = None,
+        keep_in_memory: bool = False,
+        streaming: bool = False,
+        num_proc: Optional[int] = None,
+        **kwargs,
+    ):
+        self.path_or_paths = path_or_paths
+        self.split = split if split or isinstance(path_or_paths, dict) else "train"
+        self.features = features
+        self.cache_dir = cache_dir
+        self.keep_in_memory = keep_in_memory
+        self.streaming = streaming
+        self.num_proc = num_proc
+        self.kwargs = kwargs
+
+    @abstractmethod
+    def read(self) -> Union[Dataset, DatasetDict, IterableDataset, IterableDatasetDict]:
+        pass
+
+
+class AbstractDatasetInputStream(ABC):
+    def __init__(
+        self,
+        features: Optional[Features] = None,
+        cache_dir: str = None,
+        keep_in_memory: bool = False,
+        streaming: bool = False,
+        num_proc: Optional[int] = None,
+        **kwargs,
+    ):
+        self.features = features
+        self.cache_dir = cache_dir
+        self.keep_in_memory = keep_in_memory
+        self.streaming = streaming
+        self.num_proc = num_proc
+        self.kwargs = kwargs
+
+    @abstractmethod
+    def read(self) -> Union[Dataset, IterableDataset]:
+        pass

lib/python3.10/site-packages/datasets/io/csv.py

@@ -0,0 +1,144 @@
+import multiprocessing
+import os
+from typing import BinaryIO, Optional, Union
+
+from .. import Dataset, Features, NamedSplit, config
+from ..formatting import query_table
+from ..packaged_modules.csv.csv import Csv
+from ..utils import logging
+from ..utils.typing import NestedDataStructureLike, PathLike
+from .abc import AbstractDatasetReader
+
+
+class CsvDatasetReader(AbstractDatasetReader):
+    def __init__(
+        self,
+        path_or_paths: NestedDataStructureLike[PathLike],
+        split: Optional[NamedSplit] = None,
+        features: Optional[Features] = None,
+        cache_dir: str = None,
+        keep_in_memory: bool = False,
+        streaming: bool = False,
+        num_proc: Optional[int] = None,
+        **kwargs,
+    ):
+        super().__init__(
+            path_or_paths,
+            split=split,
+            features=features,
+            cache_dir=cache_dir,
+            keep_in_memory=keep_in_memory,
+            streaming=streaming,
+            num_proc=num_proc,
+            **kwargs,
+        )
+        path_or_paths = path_or_paths if isinstance(path_or_paths, dict) else {self.split: path_or_paths}
+        self.builder = Csv(
+            cache_dir=cache_dir,
+            data_files=path_or_paths,
+            features=features,
+            **kwargs,
+        )
+
+    def read(self):
+        # Build iterable dataset
+        if self.streaming:
+            dataset = self.builder.as_streaming_dataset(split=self.split)
+        # Build regular (map-style) dataset
+        else:
+            download_config = None
+            download_mode = None
+            verification_mode = None
+            base_path = None
+
+            self.builder.download_and_prepare(
+                download_config=download_config,
+                download_mode=download_mode,
+                verification_mode=verification_mode,
+                # try_from_hf_gcs=try_from_hf_gcs,
+                base_path=base_path,
+                num_proc=self.num_proc,
+            )
+            dataset = self.builder.as_dataset(
+                split=self.split, verification_mode=verification_mode, in_memory=self.keep_in_memory
+            )
+        return dataset
+
+
+class CsvDatasetWriter:
+    def __init__(
+        self,
+        dataset: Dataset,
+        path_or_buf: Union[PathLike, BinaryIO],
+        batch_size: Optional[int] = None,
+        num_proc: Optional[int] = None,
+        **to_csv_kwargs,
+    ):
+        if num_proc is not None and num_proc <= 0:
+            raise ValueError(f"num_proc {num_proc} must be an integer > 0.")
+
+        self.dataset = dataset
+        self.path_or_buf = path_or_buf
+        self.batch_size = batch_size if batch_size else config.DEFAULT_MAX_BATCH_SIZE
+        self.num_proc = num_proc
+        self.encoding = "utf-8"
+        self.to_csv_kwargs = to_csv_kwargs
+
+    def write(self) -> int:
+        _ = self.to_csv_kwargs.pop("path_or_buf", None)
+        header = self.to_csv_kwargs.pop("header", True)
+        index = self.to_csv_kwargs.pop("index", False)
+
+        if isinstance(self.path_or_buf, (str, bytes, os.PathLike)):
+            with open(self.path_or_buf, "wb+") as buffer:
+                written = self._write(file_obj=buffer, header=header, index=index, **self.to_csv_kwargs)
+        else:
+            written = self._write(file_obj=self.path_or_buf, header=header, index=index, **self.to_csv_kwargs)
+        return written
+
+    def _batch_csv(self, args):
+        offset, header, index, to_csv_kwargs = args
+
+        batch = query_table(
+            table=self.dataset.data,
+            key=slice(offset, offset + self.batch_size),
+            indices=self.dataset._indices,
+        )
+        csv_str = batch.to_pandas().to_csv(
+            path_or_buf=None, header=header if (offset == 0) else False, index=index, **to_csv_kwargs
+        )
+        return csv_str.encode(self.encoding)
+
+    def _write(self, file_obj: BinaryIO, header, index, **to_csv_kwargs) -> int:
+        """Writes the pyarrow table as CSV to a binary file handle.
+
+        Caller is responsible for opening and closing the handle.
+        """
+        written = 0
+
+        if self.num_proc is None or self.num_proc == 1:
+            for offset in logging.tqdm(
+                range(0, len(self.dataset), self.batch_size),
+                unit="ba",
+                disable=not logging.is_progress_bar_enabled(),
+                desc="Creating CSV from Arrow format",
+            ):
+                csv_str = self._batch_csv((offset, header, index, to_csv_kwargs))
+                written += file_obj.write(csv_str)
+
+        else:
+            num_rows, batch_size = len(self.dataset), self.batch_size
+            with multiprocessing.Pool(self.num_proc) as pool:
+                for csv_str in logging.tqdm(
+                    pool.imap(
+                        self._batch_csv,
+                        [(offset, header, index, to_csv_kwargs) for offset in range(0, num_rows, batch_size)],
+                    ),
+                    total=(num_rows // batch_size) + 1 if num_rows % batch_size else num_rows // batch_size,
+                    unit="ba",
+                    disable=not logging.is_progress_bar_enabled(),
+                    desc="Creating CSV from Arrow format",
+                ):
+                    written += file_obj.write(csv_str)
+
+        return written

lib/python3.10/site-packages/datasets/io/generator.py

@@ -0,0 +1,58 @@
+from typing import Callable, Optional
+
+from .. import Features
+from ..packaged_modules.generator.generator import Generator
+from .abc import AbstractDatasetInputStream
+
+
+class GeneratorDatasetInputStream(AbstractDatasetInputStream):
+    def __init__(
+        self,
+        generator: Callable,
+        features: Optional[Features] = None,
+        cache_dir: str = None,
+        keep_in_memory: bool = False,
+        streaming: bool = False,
+        gen_kwargs: Optional[dict] = None,
+        num_proc: Optional[int] = None,
+        **kwargs,
+    ):
+        super().__init__(
+            features=features,
+            cache_dir=cache_dir,
+            keep_in_memory=keep_in_memory,
+            streaming=streaming,
+            num_proc=num_proc,
+            **kwargs,
+        )
+        self.builder = Generator(
+            cache_dir=cache_dir,
+            features=features,
+            generator=generator,
+            gen_kwargs=gen_kwargs,
+            **kwargs,
+        )
+
+    def read(self):
+        # Build iterable dataset
+        if self.streaming:
+            dataset = self.builder.as_streaming_dataset(split="train")
+        # Build regular (map-style) dataset
+        else:
+            download_config = None
+            download_mode = None
+            verification_mode = None
+            base_path = None
+
+            self.builder.download_and_prepare(
+                download_config=download_config,
+                download_mode=download_mode,
+                verification_mode=verification_mode,
+                # try_from_hf_gcs=try_from_hf_gcs,
+                base_path=base_path,
+                num_proc=self.num_proc,
+            )
+            dataset = self.builder.as_dataset(
+                split="train", verification_mode=verification_mode, in_memory=self.keep_in_memory
+            )
+        return dataset

lib/python3.10/site-packages/datasets/io/json.py

@@ -0,0 +1,169 @@
+import multiprocessing
+import os
+from typing import BinaryIO, Optional, Union
+
+import fsspec
+
+from .. import Dataset, Features, NamedSplit, config
+from ..formatting import query_table
+from ..packaged_modules.json.json import Json
+from ..utils import logging
+from ..utils.typing import NestedDataStructureLike, PathLike
+from .abc import AbstractDatasetReader
+
+
+class JsonDatasetReader(AbstractDatasetReader):
+    def __init__(
+        self,
+        path_or_paths: NestedDataStructureLike[PathLike],
+        split: Optional[NamedSplit] = None,
+        features: Optional[Features] = None,
+        cache_dir: str = None,
+        keep_in_memory: bool = False,
+        streaming: bool = False,
+        field: Optional[str] = None,
+        num_proc: Optional[int] = None,
+        **kwargs,
+    ):
+        super().__init__(
+            path_or_paths,
+            split=split,
+            features=features,
+            cache_dir=cache_dir,
+            keep_in_memory=keep_in_memory,
+            streaming=streaming,
+            num_proc=num_proc,
+            **kwargs,
+        )
+        self.field = field
+        path_or_paths = path_or_paths if isinstance(path_or_paths, dict) else {self.split: path_or_paths}
+        self.builder = Json(
+            cache_dir=cache_dir,
+            data_files=path_or_paths,
+            features=features,
+            field=field,
+            **kwargs,
+        )
+
+    def read(self):
+        # Build iterable dataset
+        if self.streaming:
+            dataset = self.builder.as_streaming_dataset(split=self.split)
+        # Build regular (map-style) dataset
+        else:
+            download_config = None
+            download_mode = None
+            verification_mode = None
+            base_path = None
+
+            self.builder.download_and_prepare(
+                download_config=download_config,
+                download_mode=download_mode,
+                verification_mode=verification_mode,
+                # try_from_hf_gcs=try_from_hf_gcs,
+                base_path=base_path,
+                num_proc=self.num_proc,
+            )
+            dataset = self.builder.as_dataset(
+                split=self.split, verification_mode=verification_mode, in_memory=self.keep_in_memory
+            )
+        return dataset
+
+
+class JsonDatasetWriter:
+    def __init__(
+        self,
+        dataset: Dataset,
+        path_or_buf: Union[PathLike, BinaryIO],
+        batch_size: Optional[int] = None,
+        num_proc: Optional[int] = None,
+        **to_json_kwargs,
+    ):
+        if num_proc is not None and num_proc <= 0:
+            raise ValueError(f"num_proc {num_proc} must be an integer > 0.")
+
+        self.dataset = dataset
+        self.path_or_buf = path_or_buf
+        self.batch_size = batch_size if batch_size else config.DEFAULT_MAX_BATCH_SIZE
+        self.num_proc = num_proc
+        self.encoding = "utf-8"
+        self.to_json_kwargs = to_json_kwargs
+
+    def write(self) -> int:
+        _ = self.to_json_kwargs.pop("path_or_buf", None)
+        orient = self.to_json_kwargs.pop("orient", "records")
+        lines = self.to_json_kwargs.pop("lines", True if orient == "records" else False)
+        index = self.to_json_kwargs.pop("index", False if orient in ["split", "table"] else True)
+        compression = self.to_json_kwargs.pop("compression", None)
+
+        if compression not in [None, "infer", "gzip", "bz2", "xz"]:
+            raise NotImplementedError(f"`datasets` currently does not support {compression} compression")
+
+        if isinstance(self.path_or_buf, (str, bytes, os.PathLike)):
+            with fsspec.open(self.path_or_buf, "wb", compression=compression) as buffer:
+                written = self._write(file_obj=buffer, orient=orient, lines=lines, index=index, **self.to_json_kwargs)
+        else:
+            if compression:
+                raise NotImplementedError(
+                    f"The compression parameter is not supported when writing to a buffer, but compression={compression}"
+                    " was passed. Please provide a local path instead."
+                )
+            written = self._write(
+                file_obj=self.path_or_buf, orient=orient, lines=lines, index=index, **self.to_json_kwargs
+            )
+        return written
+
+    def _batch_json(self, args):
+        offset, orient, lines, index, to_json_kwargs = args
+
+        batch = query_table(
+            table=self.dataset.data,
+            key=slice(offset, offset + self.batch_size),
+            indices=self.dataset._indices,
+        )
+        json_str = batch.to_pandas().to_json(
+            path_or_buf=None, orient=orient, lines=lines, index=index, **to_json_kwargs
+        )
+        if not json_str.endswith("\n"):
+            json_str += "\n"
+        return json_str.encode(self.encoding)
+
+    def _write(
+        self,
+        file_obj: BinaryIO,
+        orient,
+        lines,
+        index,
+        **to_json_kwargs,
+    ) -> int:
+        """Writes the pyarrow table as JSON lines to a binary file handle.
+
+        Caller is responsible for opening and closing the handle.
+        """
+        written = 0
+
+        if self.num_proc is None or self.num_proc == 1:
+            for offset in logging.tqdm(
+                range(0, len(self.dataset), self.batch_size),
+                unit="ba",
+                disable=not logging.is_progress_bar_enabled(),
+                desc="Creating json from Arrow format",
+            ):
+                json_str = self._batch_json((offset, orient, lines, index, to_json_kwargs))
+                written += file_obj.write(json_str)
+        else:
+            num_rows, batch_size = len(self.dataset), self.batch_size
+            with multiprocessing.Pool(self.num_proc) as pool:
+                for json_str in logging.tqdm(
+                    pool.imap(
+                        self._batch_json,
+                        [(offset, orient, lines, index, to_json_kwargs) for offset in range(0, num_rows, batch_size)],
+                    ),
+                    total=(num_rows // batch_size) + 1 if num_rows % batch_size else num_rows // batch_size,
+                    unit="ba",
+                    disable=not logging.is_progress_bar_enabled(),
+                    desc="Creating json from Arrow format",
+                ):
+                    written += file_obj.write(json_str)
+
+        return written

lib/python3.10/site-packages/datasets/io/parquet.py

@@ -0,0 +1,157 @@
+import os
+from typing import BinaryIO, Optional, Union
+
+import numpy as np
+import pyarrow.parquet as pq
+
+from .. import Audio, Dataset, Features, Image, NamedSplit, Value, config
+from ..features.features import FeatureType, _visit
+from ..formatting import query_table
+from ..packaged_modules import _PACKAGED_DATASETS_MODULES
+from ..packaged_modules.parquet.parquet import Parquet
+from ..utils import logging
+from ..utils.typing import NestedDataStructureLike, PathLike
+from .abc import AbstractDatasetReader
+
+
+def get_writer_batch_size(features: Features) -> Optional[int]:
+    """
+    Get the writer_batch_size that defines the maximum row group size in the parquet files.
+    The default in `datasets` is 1,000 but we lower it to 100 for image datasets.
+    This allows to optimize random access to parquet file, since accessing 1 row requires
+    to read its entire row group.
+
+    This can be improved to get optimized size for querying/iterating
+    but at least it matches the dataset viewer expectations on HF.
+
+    Args:
+        ds_config_info (`datasets.info.DatasetInfo`):
+            Dataset info from `datasets`.
+    Returns:
+        writer_batch_size (`Optional[int]`):
+            Writer batch size to pass to a dataset builder.
+            If `None`, then it will use the `datasets` default.
+    """
+
+    batch_size = np.inf
+
+    def set_batch_size(feature: FeatureType) -> None:
+        nonlocal batch_size
+        if isinstance(feature, Image):
+            batch_size = min(batch_size, config.PARQUET_ROW_GROUP_SIZE_FOR_IMAGE_DATASETS)
+        elif isinstance(feature, Audio):
+            batch_size = min(batch_size, config.PARQUET_ROW_GROUP_SIZE_FOR_AUDIO_DATASETS)
+        elif isinstance(feature, Value) and feature.dtype == "binary":
+            batch_size = min(batch_size, config.PARQUET_ROW_GROUP_SIZE_FOR_BINARY_DATASETS)
+
+    _visit(features, set_batch_size)
+
+    return None if batch_size is np.inf else batch_size
+
+
+class ParquetDatasetReader(AbstractDatasetReader):
+    def __init__(
+        self,
+        path_or_paths: NestedDataStructureLike[PathLike],
+        split: Optional[NamedSplit] = None,
+        features: Optional[Features] = None,
+        cache_dir: str = None,
+        keep_in_memory: bool = False,
+        streaming: bool = False,
+        num_proc: Optional[int] = None,
+        **kwargs,
+    ):
+        super().__init__(
+            path_or_paths,
+            split=split,
+            features=features,
+            cache_dir=cache_dir,
+            keep_in_memory=keep_in_memory,
+            streaming=streaming,
+            num_proc=num_proc,
+            **kwargs,
+        )
+        path_or_paths = path_or_paths if isinstance(path_or_paths, dict) else {self.split: path_or_paths}
+        hash = _PACKAGED_DATASETS_MODULES["parquet"][1]
+        self.builder = Parquet(
+            cache_dir=cache_dir,
+            data_files=path_or_paths,
+            features=features,
+            hash=hash,
+            **kwargs,
+        )
+
+    def read(self):
+        # Build iterable dataset
+        if self.streaming:
+            dataset = self.builder.as_streaming_dataset(split=self.split)
+        # Build regular (map-style) dataset
+        else:
+            download_config = None
+            download_mode = None
+            verification_mode = None
+            base_path = None
+
+            self.builder.download_and_prepare(
+                download_config=download_config,
+                download_mode=download_mode,
+                verification_mode=verification_mode,
+                # try_from_hf_gcs=try_from_hf_gcs,
+                base_path=base_path,
+                num_proc=self.num_proc,
+            )
+            dataset = self.builder.as_dataset(
+                split=self.split, verification_mode=verification_mode, in_memory=self.keep_in_memory
+            )
+        return dataset
+
+
+class ParquetDatasetWriter:
+    def __init__(
+        self,
+        dataset: Dataset,
+        path_or_buf: Union[PathLike, BinaryIO],
+        batch_size: Optional[int] = None,
+        **parquet_writer_kwargs,
+    ):
+        self.dataset = dataset
+        self.path_or_buf = path_or_buf
+        self.batch_size = batch_size or get_writer_batch_size(dataset.features)
+        self.parquet_writer_kwargs = parquet_writer_kwargs
+
+    def write(self) -> int:
+        batch_size = self.batch_size if self.batch_size else config.DEFAULT_MAX_BATCH_SIZE
+
+        if isinstance(self.path_or_buf, (str, bytes, os.PathLike)):
+            with open(self.path_or_buf, "wb+") as buffer:
+                written = self._write(file_obj=buffer, batch_size=batch_size, **self.parquet_writer_kwargs)
+        else:
+            written = self._write(file_obj=self.path_or_buf, batch_size=batch_size, **self.parquet_writer_kwargs)
+        return written
+
+    def _write(self, file_obj: BinaryIO, batch_size: int, **parquet_writer_kwargs) -> int:
+        """Writes the pyarrow table as Parquet to a binary file handle.
+
+        Caller is responsible for opening and closing the handle.
+        """
+        written = 0
+        _ = parquet_writer_kwargs.pop("path_or_buf", None)
+        schema = self.dataset.features.arrow_schema
+
+        writer = pq.ParquetWriter(file_obj, schema=schema, **parquet_writer_kwargs)
+
+        for offset in logging.tqdm(
+            range(0, len(self.dataset), batch_size),
+            unit="ba",
+            disable=not logging.is_progress_bar_enabled(),
+            desc="Creating parquet from Arrow format",
+        ):
+            batch = query_table(
+                table=self.dataset._data,
+                key=slice(offset, offset + batch_size),
+                indices=self.dataset._indices if self.dataset._indices is not None else None,
+            )
+            writer.write_table(batch)
+            written += batch.nbytes
+        writer.close()
+        return written

lib/python3.10/site-packages/datasets/io/spark.py

@@ -0,0 +1,57 @@
+from typing import Optional
+
+import pyspark
+
+from .. import Features, NamedSplit
+from ..download import DownloadMode
+from ..packaged_modules.spark.spark import Spark
+from .abc import AbstractDatasetReader
+
+
+class SparkDatasetReader(AbstractDatasetReader):
+    """A dataset reader that reads from a Spark DataFrame.
+
+    When caching, cache materialization is parallelized over Spark; an NFS that is accessible to the driver must be
+    provided. Streaming is not currently supported.
+    """
+
+    def __init__(
+        self,
+        df: pyspark.sql.DataFrame,
+        split: Optional[NamedSplit] = None,
+        features: Optional[Features] = None,
+        streaming: bool = True,
+        cache_dir: str = None,
+        keep_in_memory: bool = False,
+        working_dir: str = None,
+        load_from_cache_file: bool = True,
+        file_format: str = "arrow",
+        **kwargs,
+    ):
+        super().__init__(
+            split=split,
+            features=features,
+            cache_dir=cache_dir,
+            keep_in_memory=keep_in_memory,
+            streaming=streaming,
+            **kwargs,
+        )
+        self._load_from_cache_file = load_from_cache_file
+        self._file_format = file_format
+        self.builder = Spark(
+            df=df,
+            features=features,
+            cache_dir=cache_dir,
+            working_dir=working_dir,
+            **kwargs,
+        )
+
+    def read(self):
+        if self.streaming:
+            return self.builder.as_streaming_dataset(split=self.split)
+        download_mode = None if self._load_from_cache_file else DownloadMode.FORCE_REDOWNLOAD
+        self.builder.download_and_prepare(
+            download_mode=download_mode,
+            file_format=self._file_format,
+        )
+        return self.builder.as_dataset(split=self.split)

lib/python3.10/site-packages/datasets/io/sql.py

@@ -0,0 +1,127 @@
+import multiprocessing
+from typing import TYPE_CHECKING, Optional, Union
+
+from .. import Dataset, Features, config
+from ..formatting import query_table
+from ..packaged_modules.sql.sql import Sql
+from ..utils import logging
+from .abc import AbstractDatasetInputStream
+
+
+if TYPE_CHECKING:
+    import sqlite3
+
+    import sqlalchemy
+
+
+class SqlDatasetReader(AbstractDatasetInputStream):
+    def __init__(
+        self,
+        sql: Union[str, "sqlalchemy.sql.Selectable"],
+        con: Union[str, "sqlalchemy.engine.Connection", "sqlalchemy.engine.Engine", "sqlite3.Connection"],
+        features: Optional[Features] = None,
+        cache_dir: str = None,
+        keep_in_memory: bool = False,
+        **kwargs,
+    ):
+        super().__init__(features=features, cache_dir=cache_dir, keep_in_memory=keep_in_memory, **kwargs)
+        self.builder = Sql(
+            cache_dir=cache_dir,
+            features=features,
+            sql=sql,
+            con=con,
+            **kwargs,
+        )
+
+    def read(self):
+        download_config = None
+        download_mode = None
+        verification_mode = None
+        base_path = None
+
+        self.builder.download_and_prepare(
+            download_config=download_config,
+            download_mode=download_mode,
+            verification_mode=verification_mode,
+            # try_from_hf_gcs=try_from_hf_gcs,
+            base_path=base_path,
+        )
+
+        # Build dataset for splits
+        dataset = self.builder.as_dataset(
+            split="train", verification_mode=verification_mode, in_memory=self.keep_in_memory
+        )
+        return dataset
+
+
+class SqlDatasetWriter:
+    def __init__(
+        self,
+        dataset: Dataset,
+        name: str,
+        con: Union[str, "sqlalchemy.engine.Connection", "sqlalchemy.engine.Engine", "sqlite3.Connection"],
+        batch_size: Optional[int] = None,
+        num_proc: Optional[int] = None,
+        **to_sql_kwargs,
+    ):
+        if num_proc is not None and num_proc <= 0:
+            raise ValueError(f"num_proc {num_proc} must be an integer > 0.")
+
+        self.dataset = dataset
+        self.name = name
+        self.con = con
+        self.batch_size = batch_size if batch_size else config.DEFAULT_MAX_BATCH_SIZE
+        self.num_proc = num_proc
+        self.to_sql_kwargs = to_sql_kwargs
+
+    def write(self) -> int:
+        _ = self.to_sql_kwargs.pop("sql", None)
+        _ = self.to_sql_kwargs.pop("con", None)
+        index = self.to_sql_kwargs.pop("index", False)
+
+        written = self._write(index=index, **self.to_sql_kwargs)
+        return written
+
+    def _batch_sql(self, args):
+        offset, index, to_sql_kwargs = args
+        to_sql_kwargs = {**to_sql_kwargs, "if_exists": "append"} if offset > 0 else to_sql_kwargs
+        batch = query_table(
+            table=self.dataset.data,
+            key=slice(offset, offset + self.batch_size),
+            indices=self.dataset._indices,
+        )
+        df = batch.to_pandas()
+        num_rows = df.to_sql(self.name, self.con, index=index, **to_sql_kwargs)
+        return num_rows or len(df)
+
+    def _write(self, index, **to_sql_kwargs) -> int:
+        """Writes the pyarrow table as SQL to a database.
+
+        Caller is responsible for opening and closing the SQL connection.
+        """
+        written = 0
+
+        if self.num_proc is None or self.num_proc == 1:
+            for offset in logging.tqdm(
+                range(0, len(self.dataset), self.batch_size),
+                unit="ba",
+                disable=not logging.is_progress_bar_enabled(),
+                desc="Creating SQL from Arrow format",
+            ):
+                written += self._batch_sql((offset, index, to_sql_kwargs))
+        else:
+            num_rows, batch_size = len(self.dataset), self.batch_size
+            with multiprocessing.Pool(self.num_proc) as pool:
+                for num_rows in logging.tqdm(
+                    pool.imap(
+                        self._batch_sql,
+                        [(offset, index, to_sql_kwargs) for offset in range(0, num_rows, batch_size)],
+                    ),
+                    total=(num_rows // batch_size) + 1 if num_rows % batch_size else num_rows // batch_size,
+                    unit="ba",
+                    disable=not logging.is_progress_bar_enabled(),
+                    desc="Creating SQL from Arrow format",
+                ):
+                    written += num_rows
+
+        return written

lib/python3.10/site-packages/datasets/io/text.py

@@ -0,0 +1,61 @@
+from typing import Optional
+
+from .. import Features, NamedSplit
+from ..packaged_modules.text.text import Text
+from ..utils.typing import NestedDataStructureLike, PathLike
+from .abc import AbstractDatasetReader
+
+
+class TextDatasetReader(AbstractDatasetReader):
+    def __init__(
+        self,
+        path_or_paths: NestedDataStructureLike[PathLike],
+        split: Optional[NamedSplit] = None,
+        features: Optional[Features] = None,
+        cache_dir: str = None,
+        keep_in_memory: bool = False,
+        streaming: bool = False,
+        num_proc: Optional[int] = None,
+        **kwargs,
+    ):
+        super().__init__(
+            path_or_paths,
+            split=split,
+            features=features,
+            cache_dir=cache_dir,
+            keep_in_memory=keep_in_memory,
+            streaming=streaming,
+            num_proc=num_proc,
+            **kwargs,
+        )
+        path_or_paths = path_or_paths if isinstance(path_or_paths, dict) else {self.split: path_or_paths}
+        self.builder = Text(
+            cache_dir=cache_dir,
+            data_files=path_or_paths,
+            features=features,
+            **kwargs,
+        )
+
+    def read(self):
+        # Build iterable dataset
+        if self.streaming:
+            dataset = self.builder.as_streaming_dataset(split=self.split)
+        # Build regular (map-style) dataset
+        else:
+            download_config = None
+            download_mode = None
+            verification_mode = None
+            base_path = None
+
+            self.builder.download_and_prepare(
+                download_config=download_config,
+                download_mode=download_mode,
+                verification_mode=verification_mode,
+                # try_from_hf_gcs=try_from_hf_gcs,
+                base_path=base_path,
+                num_proc=self.num_proc,
+            )
+            dataset = self.builder.as_dataset(
+                split=self.split, verification_mode=verification_mode, in_memory=self.keep_in_memory
+            )
+        return dataset

lib/python3.10/site-packages/datasets/packaged_modules/arrow/arrow.py

@@ -0,0 +1,73 @@
+import itertools
+from dataclasses import dataclass
+from typing import Optional
+
+import pyarrow as pa
+
+import datasets
+from datasets.table import table_cast
+
+
+logger = datasets.utils.logging.get_logger(__name__)
+
+
+@dataclass
+class ArrowConfig(datasets.BuilderConfig):
+    """BuilderConfig for Arrow."""
+
+    features: Optional[datasets.Features] = None
+
+
+class Arrow(datasets.ArrowBasedBuilder):
+    BUILDER_CONFIG_CLASS = ArrowConfig
+
+    def _info(self):
+        return datasets.DatasetInfo(features=self.config.features)
+
+    def _split_generators(self, dl_manager):
+        """We handle string, list and dicts in datafiles"""
+        if not self.config.data_files:
+            raise ValueError(f"At least one data file must be specified, but got data_files={self.config.data_files}")
+        data_files = dl_manager.download_and_extract(self.config.data_files)
+        if isinstance(data_files, (str, list, tuple)):
+            files = data_files
+            if isinstance(files, str):
+                files = [files]
+            # Use `dl_manager.iter_files` to skip hidden files in an extracted archive
+            files = [dl_manager.iter_files(file) for file in files]
+            return [datasets.SplitGenerator(name=datasets.Split.TRAIN, gen_kwargs={"files": files})]
+        splits = []
+        for split_name, files in data_files.items():
+            if isinstance(files, str):
+                files = [files]
+            # Use `dl_manager.iter_files` to skip hidden files in an extracted archive
+            files = [dl_manager.iter_files(file) for file in files]
+            # Infer features is they are stoed in the arrow schema
+            if self.info.features is None:
+                for file in itertools.chain.from_iterable(files):
+                    with open(file, "rb") as f:
+                        self.info.features = datasets.Features.from_arrow_schema(pa.ipc.open_stream(f).schema)
+                    break
+            splits.append(datasets.SplitGenerator(name=split_name, gen_kwargs={"files": files}))
+        return splits
+
+    def _cast_table(self, pa_table: pa.Table) -> pa.Table:
+        if self.info.features is not None:
+            # more expensive cast to support nested features with keys in a different order
+            # allows str <-> int/float or str to Audio for example
+            pa_table = table_cast(pa_table, self.info.features.arrow_schema)
+        return pa_table
+
+    def _generate_tables(self, files):
+        for file_idx, file in enumerate(itertools.chain.from_iterable(files)):
+            with open(file, "rb") as f:
+                try:
+                    for batch_idx, record_batch in enumerate(pa.ipc.open_stream(f)):
+                        pa_table = pa.Table.from_batches([record_batch])
+                        # Uncomment for debugging (will print the Arrow table size and elements)
+                        # logger.warning(f"pa_table: {pa_table} num rows: {pa_table.num_rows}")
+                        # logger.warning('\n'.join(str(pa_table.slice(i, 1).to_pydict()) for i in range(pa_table.num_rows)))
+                        yield f"{file_idx}_{batch_idx}", self._cast_table(pa_table)
+                except ValueError as e:
+                    logger.error(f"Failed to read file '{file}' with error {type(e)}: {e}")
+                    raise

lib/python3.10/site-packages/datasets/packaged_modules/csv/csv.py

@@ -0,0 +1,195 @@
+import itertools
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, List, Optional, 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
+from datasets.utils.py_utils import Literal
+
+
+logger = datasets.utils.logging.get_logger(__name__)
+
+_PANDAS_READ_CSV_NO_DEFAULT_PARAMETERS = ["names", "prefix"]
+_PANDAS_READ_CSV_DEPRECATED_PARAMETERS = ["warn_bad_lines", "error_bad_lines", "mangle_dupe_cols"]
+_PANDAS_READ_CSV_NEW_1_3_0_PARAMETERS = ["encoding_errors", "on_bad_lines"]
+_PANDAS_READ_CSV_NEW_2_0_0_PARAMETERS = ["date_format"]
+
+
+@dataclass
+class CsvConfig(datasets.BuilderConfig):
+    """BuilderConfig for CSV."""
+
+    sep: str = ","
+    delimiter: Optional[str] = None
+    header: Optional[Union[int, List[int], str]] = "infer"
+    names: Optional[List[str]] = None
+    column_names: Optional[List[str]] = None
+    index_col: Optional[Union[int, str, List[int], List[str]]] = None
+    usecols: Optional[Union[List[int], List[str]]] = None
+    prefix: Optional[str] = None
+    mangle_dupe_cols: bool = True
+    engine: Optional[Literal["c", "python", "pyarrow"]] = None
+    converters: Dict[Union[int, str], Callable[[Any], Any]] = None
+    true_values: Optional[list] = None
+    false_values: Optional[list] = None
+    skipinitialspace: bool = False
+    skiprows: Optional[Union[int, List[int]]] = None
+    nrows: Optional[int] = None
+    na_values: Optional[Union[str, List[str]]] = None
+    keep_default_na: bool = True
+    na_filter: bool = True
+    verbose: bool = False
+    skip_blank_lines: bool = True
+    thousands: Optional[str] = None
+    decimal: str = "."
+    lineterminator: Optional[str] = None
+    quotechar: str = '"'
+    quoting: int = 0
+    escapechar: Optional[str] = None
+    comment: Optional[str] = None
+    encoding: Optional[str] = None
+    dialect: Optional[str] = None
+    error_bad_lines: bool = True
+    warn_bad_lines: bool = True
+    skipfooter: int = 0
+    doublequote: bool = True
+    memory_map: bool = False
+    float_precision: Optional[str] = None
+    chunksize: int = 10_000
+    features: Optional[datasets.Features] = None
+    encoding_errors: Optional[str] = "strict"
+    on_bad_lines: Literal["error", "warn", "skip"] = "error"
+    date_format: Optional[str] = None
+
+    def __post_init__(self):
+        if self.delimiter is not None:
+            self.sep = self.delimiter
+        if self.column_names is not None:
+            self.names = self.column_names
+
+    @property
+    def pd_read_csv_kwargs(self):
+        pd_read_csv_kwargs = {
+            "sep": self.sep,
+            "header": self.header,
+            "names": self.names,
+            "index_col": self.index_col,
+            "usecols": self.usecols,
+            "prefix": self.prefix,
+            "mangle_dupe_cols": self.mangle_dupe_cols,
+            "engine": self.engine,
+            "converters": self.converters,
+            "true_values": self.true_values,
+            "false_values": self.false_values,
+            "skipinitialspace": self.skipinitialspace,
+            "skiprows": self.skiprows,
+            "nrows": self.nrows,
+            "na_values": self.na_values,
+            "keep_default_na": self.keep_default_na,
+            "na_filter": self.na_filter,
+            "verbose": self.verbose,
+            "skip_blank_lines": self.skip_blank_lines,
+            "thousands": self.thousands,
+            "decimal": self.decimal,
+            "lineterminator": self.lineterminator,
+            "quotechar": self.quotechar,
+            "quoting": self.quoting,
+            "escapechar": self.escapechar,
+            "comment": self.comment,
+            "encoding": self.encoding,
+            "dialect": self.dialect,
+            "error_bad_lines": self.error_bad_lines,
+            "warn_bad_lines": self.warn_bad_lines,
+            "skipfooter": self.skipfooter,
+            "doublequote": self.doublequote,
+            "memory_map": self.memory_map,
+            "float_precision": self.float_precision,
+            "chunksize": self.chunksize,
+            "encoding_errors": self.encoding_errors,
+            "on_bad_lines": self.on_bad_lines,
+            "date_format": self.date_format,
+        }
+
+        # some kwargs must not be passed if they don't have a default value
+        # some others are deprecated and we can also not pass them if they are the default value
+        for pd_read_csv_parameter in _PANDAS_READ_CSV_NO_DEFAULT_PARAMETERS + _PANDAS_READ_CSV_DEPRECATED_PARAMETERS:
+            if pd_read_csv_kwargs[pd_read_csv_parameter] == getattr(CsvConfig(), pd_read_csv_parameter):
+                del pd_read_csv_kwargs[pd_read_csv_parameter]
+
+        # Remove 2.0 new arguments
+        if not (datasets.config.PANDAS_VERSION.major >= 2):
+            for pd_read_csv_parameter in _PANDAS_READ_CSV_NEW_2_0_0_PARAMETERS:
+                del pd_read_csv_kwargs[pd_read_csv_parameter]
+
+        # Remove 1.3 new arguments
+        if not (datasets.config.PANDAS_VERSION.major >= 1 and datasets.config.PANDAS_VERSION.minor >= 3):
+            for pd_read_csv_parameter in _PANDAS_READ_CSV_NEW_1_3_0_PARAMETERS:
+                del pd_read_csv_kwargs[pd_read_csv_parameter]
+
+        return pd_read_csv_kwargs
+
+
+class Csv(datasets.ArrowBasedBuilder):
+    BUILDER_CONFIG_CLASS = CsvConfig
+
+    def _info(self):
+        return datasets.DatasetInfo(features=self.config.features)
+
+    def _split_generators(self, dl_manager):
+        """We handle string, list and dicts in datafiles"""
+        if not self.config.data_files:
+            raise ValueError(f"At least one data file must be specified, but got data_files={self.config.data_files}")
+        data_files = dl_manager.download_and_extract(self.config.data_files)
+        if isinstance(data_files, (str, list, tuple)):
+            files = data_files
+            if isinstance(files, str):
+                files = [files]
+            files = [dl_manager.iter_files(file) for file in files]
+            return [datasets.SplitGenerator(name=datasets.Split.TRAIN, gen_kwargs={"files": files})]
+        splits = []
+        for split_name, files in data_files.items():
+            if isinstance(files, str):
+                files = [files]
+            files = [dl_manager.iter_files(file) for file in files]
+            splits.append(datasets.SplitGenerator(name=split_name, gen_kwargs={"files": files}))
+        return splits
+
+    def _cast_table(self, pa_table: pa.Table) -> pa.Table:
+        if self.config.features is not None:
+            schema = self.config.features.arrow_schema
+            if all(not require_storage_cast(feature) for feature in self.config.features.values()):
+                # cheaper cast
+                pa_table = pa.Table.from_arrays([pa_table[field.name] for field in schema], schema=schema)
+            else:
+                # more expensive cast; allows str <-> int/float or str to Audio for example
+                pa_table = table_cast(pa_table, schema)
+        return pa_table
+
+    def _generate_tables(self, files):
+        schema = self.config.features.arrow_schema if self.config.features else None
+        # dtype allows reading an int column as str
+        dtype = (
+            {
+                name: dtype.to_pandas_dtype() if not require_storage_cast(feature) else object
+                for name, dtype, feature in zip(schema.names, schema.types, self.config.features.values())
+            }
+            if schema is not None
+            else None
+        )
+        for file_idx, file in enumerate(itertools.chain.from_iterable(files)):
+            csv_file_reader = pd.read_csv(file, iterator=True, dtype=dtype, **self.config.pd_read_csv_kwargs)
+            try:
+                for batch_idx, df in enumerate(csv_file_reader):
+                    pa_table = pa.Table.from_pandas(df)
+                    # Uncomment for debugging (will print the Arrow table size and elements)
+                    # logger.warning(f"pa_table: {pa_table} num rows: {pa_table.num_rows}")
+                    # logger.warning('\n'.join(str(pa_table.slice(i, 1).to_pydict()) for i in range(pa_table.num_rows)))
+                    yield (file_idx, batch_idx), self._cast_table(pa_table)
+            except ValueError as e:
+                logger.error(f"Failed to read file '{file}' with error {type(e)}: {e}")
+                raise

lib/python3.10/site-packages/datasets/packaged_modules/generator/generator.py

@@ -0,0 +1,31 @@
+from dataclasses import dataclass
+from typing import Callable, Optional
+
+import datasets
+
+
+@dataclass
+class GeneratorConfig(datasets.BuilderConfig):
+    generator: Optional[Callable] = None
+    gen_kwargs: Optional[dict] = None
+    features: Optional[datasets.Features] = None
+
+    def __post_init__(self):
+        assert self.generator is not None, "generator must be specified"
+
+        if self.gen_kwargs is None:
+            self.gen_kwargs = {}
+
+
+class Generator(datasets.GeneratorBasedBuilder):
+    BUILDER_CONFIG_CLASS = GeneratorConfig
+
+    def _info(self):
+        return datasets.DatasetInfo(features=self.config.features)
+
+    def _split_generators(self, dl_manager):
+        return [datasets.SplitGenerator(name=datasets.Split.TRAIN, gen_kwargs=self.config.gen_kwargs)]
+
+    def _generate_examples(self, **gen_kwargs):
+        for idx, ex in enumerate(self.config.generator(**gen_kwargs)):
+            yield idx, ex

lib/python3.10/site-packages/datasets/packaged_modules/json/json.py

@@ -0,0 +1,171 @@
+import io
+import itertools
+import json
+from dataclasses import dataclass
+from typing import Optional
+
+import pyarrow as pa
+import pyarrow.json as paj
+
+import datasets
+from datasets.table import table_cast
+from datasets.utils.file_utils import readline
+
+
+logger = datasets.utils.logging.get_logger(__name__)
+
+
+@dataclass
+class JsonConfig(datasets.BuilderConfig):
+    """BuilderConfig for JSON."""
+
+    features: Optional[datasets.Features] = None
+    encoding: str = "utf-8"
+    encoding_errors: Optional[str] = None
+    field: Optional[str] = None
+    use_threads: bool = True  # deprecated
+    block_size: Optional[int] = None  # deprecated
+    chunksize: int = 10 << 20  # 10MB
+    newlines_in_values: Optional[bool] = None
+
+
+class Json(datasets.ArrowBasedBuilder):
+    BUILDER_CONFIG_CLASS = JsonConfig
+
+    def _info(self):
+        if self.config.block_size is not None:
+            logger.warning("The JSON loader parameter `block_size` is deprecated. Please use `chunksize` instead")
+            self.config.chunksize = self.config.block_size
+        if self.config.use_threads is not True:
+            logger.warning(
+                "The JSON loader parameter `use_threads` is deprecated and doesn't have any effect anymore."
+            )
+        if self.config.newlines_in_values is not None:
+            raise ValueError("The JSON loader parameter `newlines_in_values` is no longer supported")
+        return datasets.DatasetInfo(features=self.config.features)
+
+    def _split_generators(self, dl_manager):
+        """We handle string, list and dicts in datafiles"""
+        if not self.config.data_files:
+            raise ValueError(f"At least one data file must be specified, but got data_files={self.config.data_files}")
+        data_files = dl_manager.download_and_extract(self.config.data_files)
+        if isinstance(data_files, (str, list, tuple)):
+            files = data_files
+            if isinstance(files, str):
+                files = [files]
+            files = [dl_manager.iter_files(file) for file in files]
+            return [datasets.SplitGenerator(name=datasets.Split.TRAIN, gen_kwargs={"files": files})]
+        splits = []
+        for split_name, files in data_files.items():
+            if isinstance(files, str):
+                files = [files]
+            files = [dl_manager.iter_files(file) for file in files]
+            splits.append(datasets.SplitGenerator(name=split_name, gen_kwargs={"files": files}))
+        return splits
+
+    def _cast_table(self, pa_table: pa.Table) -> pa.Table:
+        if self.config.features is not None:
+            # adding missing columns
+            for column_name in set(self.config.features) - set(pa_table.column_names):
+                type = self.config.features.arrow_schema.field(column_name).type
+                pa_table = pa_table.append_column(column_name, pa.array([None] * len(pa_table), type=type))
+            # more expensive cast to support nested structures with keys in a different order
+            # allows str <-> int/float or str to Audio for example
+            pa_table = table_cast(pa_table, self.config.features.arrow_schema)
+        return pa_table
+
+    def _generate_tables(self, files):
+        for file_idx, file in enumerate(itertools.chain.from_iterable(files)):
+            # If the file is one json object and if we need to look at the list of items in one specific field
+            if self.config.field is not None:
+                with open(file, encoding=self.config.encoding, errors=self.config.encoding_errors) as f:
+                    dataset = json.load(f)
+
+                # We keep only the field we are interested in
+                dataset = dataset[self.config.field]
+
+                # We accept two format: a list of dicts or a dict of lists
+                if isinstance(dataset, (list, tuple)):
+                    keys = set().union(*[row.keys() for row in dataset])
+                    mapping = {col: [row.get(col) for row in dataset] for col in keys}
+                else:
+                    mapping = dataset
+                pa_table = pa.Table.from_pydict(mapping)
+                yield file_idx, self._cast_table(pa_table)
+
+            # If the file has one json object per line
+            else:
+                with open(file, "rb") as f:
+                    batch_idx = 0
+                    # Use block_size equal to the chunk size divided by 32 to leverage multithreading
+                    # Set a default minimum value of 16kB if the chunk size is really small
+                    block_size = max(self.config.chunksize // 32, 16 << 10)
+                    encoding_errors = (
+                        self.config.encoding_errors if self.config.encoding_errors is not None else "strict"
+                    )
+                    while True:
+                        batch = f.read(self.config.chunksize)
+                        if not batch:
+                            break
+                        # Finish current line
+                        try:
+                            batch += f.readline()
+                        except (AttributeError, io.UnsupportedOperation):
+                            batch += readline(f)
+                        # PyArrow only accepts utf-8 encoded bytes
+                        if self.config.encoding != "utf-8":
+                            batch = batch.decode(self.config.encoding, errors=encoding_errors).encode("utf-8")
+                        try:
+                            while True:
+                                try:
+                                    pa_table = paj.read_json(
+                                        io.BytesIO(batch), read_options=paj.ReadOptions(block_size=block_size)
+                                    )
+                                    break
+                                except (pa.ArrowInvalid, pa.ArrowNotImplementedError) as e:
+                                    if (
+                                        isinstance(e, pa.ArrowInvalid)
+                                        and "straddling" not in str(e)
+                                        or block_size > len(batch)
+                                    ):
+                                        raise
+                                    else:
+                                        # Increase the block size in case it was too small.
+                                        # The block size will be reset for the next file.
+                                        logger.debug(
+                                            f"Batch of {len(batch)} bytes couldn't be parsed with block_size={block_size}. Retrying with block_size={block_size * 2}."
+                                        )
+                                        block_size *= 2
+                        except pa.ArrowInvalid as e:
+                            try:
+                                with open(
+                                    file, encoding=self.config.encoding, errors=self.config.encoding_errors
+                                ) as f:
+                                    dataset = json.load(f)
+                            except json.JSONDecodeError:
+                                logger.error(f"Failed to read file '{file}' with error {type(e)}: {e}")
+                                raise e
+                            # If possible, parse the file as a list of json objects and exit the loop
+                            if isinstance(dataset, list):  # list is the only sequence type supported in JSON
+                                try:
+                                    keys = set().union(*[row.keys() for row in dataset])
+                                    mapping = {col: [row.get(col) for row in dataset] for col in keys}
+                                    pa_table = pa.Table.from_pydict(mapping)
+                                except (pa.ArrowInvalid, AttributeError) as e:
+                                    logger.error(f"Failed to read file '{file}' with error {type(e)}: {e}")
+                                    raise ValueError(f"Not able to read records in the JSON file at {file}.") from None
+                                yield file_idx, self._cast_table(pa_table)
+                                break
+                            else:
+                                logger.error(f"Failed to read file '{file}' with error {type(e)}: {e}")
+                                raise ValueError(
+                                    f"Not able to read records in the JSON file at {file}. "
+                                    f"You should probably indicate the field of the JSON file containing your records. "
+                                    f"This JSON file contain the following fields: {str(list(dataset.keys()))}. "
+                                    f"Select the correct one and provide it as `field='XXX'` to the dataset loading method. "
+                                ) from None
+                        # Uncomment for debugging (will print the Arrow table size and elements)
+                        # logger.warning(f"pa_table: {pa_table} num rows: {pa_table.num_rows}")
+                        # logger.warning('\n'.join(str(pa_table.slice(i, 1).to_pydict()) for i in range(pa_table.num_rows)))
+                        yield (file_idx, batch_idx), self._cast_table(pa_table)
+                        batch_idx += 1

lib/python3.10/site-packages/datasets/packaged_modules/sql/sql.py

@@ -0,0 +1,118 @@
+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 sqlite3
+
+    import sqlalchemy
+
+
+logger = datasets.utils.logging.get_logger(__name__)
+
+
+@dataclass
+class SqlConfig(datasets.BuilderConfig):
+    """BuilderConfig for SQL."""
+
+    sql: Union[str, "sqlalchemy.sql.Selectable"] = None
+    con: Union[str, "sqlalchemy.engine.Connection", "sqlalchemy.engine.Engine", "sqlite3.Connection"] = None
+    index_col: Optional[Union[str, List[str]]] = None
+    coerce_float: bool = True
+    params: Optional[Union[List, Tuple, Dict]] = None
+    parse_dates: Optional[Union[List, Dict]] = None
+    columns: Optional[List[str]] = None
+    chunksize: Optional[int] = 10_000
+    features: Optional[datasets.Features] = None
+
+    def __post_init__(self):
+        if self.sql is None:
+            raise ValueError("sql must be specified")
+        if self.con is None:
+            raise ValueError("con must be specified")
+
+    def create_config_id(
+        self,
+        config_kwargs: dict,
+        custom_features: Optional[datasets.Features] = None,
+    ) -> str:
+        config_kwargs = 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
+        sql = config_kwargs["sql"]
+        if not isinstance(sql, str):
+            if datasets.config.SQLALCHEMY_AVAILABLE and "sqlalchemy" in sys.modules:
+                import sqlalchemy
+
+                if isinstance(sql, sqlalchemy.sql.Selectable):
+                    engine = sqlalchemy.create_engine(config_kwargs["con"].split("://")[0] + "://")
+                    sql_str = str(sql.compile(dialect=engine.dialect))
+                    config_kwargs["sql"] = sql_str
+                else:
+                    raise TypeError(
+                        f"Supported types for 'sql' are string and sqlalchemy.sql.Selectable but got {type(sql)}: {sql}"
+                    )
+            else:
+                raise TypeError(
+                    f"Supported types for 'sql' are string and sqlalchemy.sql.Selectable but got {type(sql)}: {sql}"
+                )
+        con = config_kwargs["con"]
+        if not isinstance(con, str):
+            config_kwargs["con"] = id(con)
+            logger.info(
+                f"SQL connection 'con' of type {type(con)} couldn't be hashed properly. To enable hashing, specify 'con' as URI string instead."
+            )
+
+        return super().create_config_id(config_kwargs, custom_features=custom_features)
+
+    @property
+    def pd_read_sql_kwargs(self):
+        pd_read_sql_kwargs = {
+            "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 Sql(datasets.ArrowBasedBuilder):
+    BUILDER_CONFIG_CLASS = SqlConfig
+
+    def _info(self):
+        return datasets.DatasetInfo(features=self.config.features)
+
+    def _split_generators(self, dl_manager):
+        return [datasets.SplitGenerator(name=datasets.Split.TRAIN, gen_kwargs={})]
+
+    def _cast_table(self, pa_table: pa.Table) -> pa.Table:
+        if self.config.features is not None:
+            schema = self.config.features.arrow_schema
+            if all(not require_storage_cast(feature) for feature in self.config.features.values()):
+                # cheaper cast
+                pa_table = pa.Table.from_arrays([pa_table[field.name] for field in schema], schema=schema)
+            else:
+                # more expensive cast; allows str <-> int/float or str to Audio for example
+                pa_table = table_cast(pa_table, schema)
+        return pa_table
+
+    def _generate_tables(self):
+        chunksize = self.config.chunksize
+        sql_reader = pd.read_sql(
+            self.config.sql, self.config.con, chunksize=chunksize, **self.config.pd_read_sql_kwargs
+        )
+        sql_reader = [sql_reader] if chunksize is None else sql_reader
+        for chunk_idx, df in enumerate(sql_reader):
+            pa_table = pa.Table.from_pandas(df)
+            yield chunk_idx, self._cast_table(pa_table)

lib/python3.10/site-packages/dlinfo-2.0.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+uv

lib/python3.10/site-packages/dlinfo-2.0.0.dist-info/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2019 Catalysts GmbH, a Cloudflight Company <space@catalysts.cc>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

lib/python3.10/site-packages/dlinfo-2.0.0.dist-info/METADATA

@@ -0,0 +1,43 @@
+Metadata-Version: 2.1
+Name: dlinfo
+Version: 2.0.0
+Summary: Python wrapper for libc's dlinfo and dyld_find on Mac
+Home-page: https://github.com/fphammerle/python-dlinfo
+Maintainer: Fabian Peter Hammerle
+Maintainer-email: fabian.dlinfo@hammerle.me
+License: MIT
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.9
+License-File: LICENSE
+
+python-dlinfo
+=============
+
+Python wrapper for libc's dlinfo
+
+Install
+-------
+
+.. code:: sh
+
+   pip install dlinfo
+   # or
+   pipenv install dlinfo
+
+Usage
+-----
+
+.. code:: python
+
+   >>> from dlinfo import DLInfo
+   >>> lib = ctypes.cdll.LoadLibrary(ctypes.util.find_library('c'))
+   >>> dlinfo = DLInfo(lib)
+   >>> dlinfo.path
+   '/lib/x86_64-linux-gnu/libc.so.6'

lib/python3.10/site-packages/dlinfo-2.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+dlinfo-2.0.0.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
+dlinfo-2.0.0.dist-info/LICENSE,sha256=H9hqUp3q1-1XMLNmCAu9EGZdWIkT_S2c5Q6zoWEJX7k,1098
+dlinfo-2.0.0.dist-info/METADATA,sha256=OAw2-t1rNPAdqmpKtRN5zSVjtH-f-_QPfHALsKaN8Tg,1070
+dlinfo-2.0.0.dist-info/RECORD,,
+dlinfo-2.0.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dlinfo-2.0.0.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+dlinfo-2.0.0.dist-info/top_level.txt,sha256=JZ0mAh2JRPwKUx0iZgbGA9bPo3zUXdZ7JLWl4TAUxiE,7
+dlinfo/__init__.py,sha256=muJlk1jFQBz5e70hI5N8ntlaKybPu4890HoRu1MKZ_M,192
+dlinfo/_glibc.py,sha256=PYEb2ZLL29xAodLRHaCcu2Bg3F7lLMyxI1Fqw93dKqo,1278
+dlinfo/_macosx.py,sha256=h8lOieLm7-hoIYhzipyFHuj52JGewYVAvGafwcYoAWI,523

lib/python3.10/site-packages/dlinfo-2.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.38.4)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

lib/python3.10/site-packages/dlinfo-2.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+dlinfo

lib/python3.10/site-packages/importlib_resources/__init__.py

@@ -0,0 +1,40 @@
+"""
+Read resources contained within a package.
+
+This codebase is shared between importlib.resources in the stdlib
+and importlib_resources in PyPI. See
+https://github.com/python/importlib_metadata/wiki/Development-Methodology
+for more detail.
+"""
+
+from ._common import (
+    Anchor,
+    Package,
+    as_file,
+    files,
+)
+from ._functional import (
+    contents,
+    is_resource,
+    open_binary,
+    open_text,
+    path,
+    read_binary,
+    read_text,
+)
+from .abc import ResourceReader
+
+__all__ = [
+    'Package',
+    'Anchor',
+    'ResourceReader',
+    'as_file',
+    'files',
+    'contents',
+    'is_resource',
+    'open_binary',
+    'open_text',
+    'path',
+    'read_binary',
+    'read_text',
+]

lib/python3.10/site-packages/importlib_resources/_adapters.py

@@ -0,0 +1,168 @@
+from contextlib import suppress
+from io import TextIOWrapper
+
+from . import abc
+
+
+class SpecLoaderAdapter:
+    """
+    Adapt a package spec to adapt the underlying loader.
+    """
+
+    def __init__(self, spec, adapter=lambda spec: spec.loader):
+        self.spec = spec
+        self.loader = adapter(spec)
+
+    def __getattr__(self, name):
+        return getattr(self.spec, name)
+
+
+class TraversableResourcesLoader:
+    """
+    Adapt a loader to provide TraversableResources.
+    """
+
+    def __init__(self, spec):
+        self.spec = spec
+
+    def get_resource_reader(self, name):
+        return CompatibilityFiles(self.spec)._native()
+
+
+def _io_wrapper(file, mode='r', *args, **kwargs):
+    if mode == 'r':
+        return TextIOWrapper(file, *args, **kwargs)
+    elif mode == 'rb':
+        return file
+    raise ValueError(f"Invalid mode value '{mode}', only 'r' and 'rb' are supported")
+
+
+class CompatibilityFiles:
+    """
+    Adapter for an existing or non-existent resource reader
+    to provide a compatibility .files().
+    """
+
+    class SpecPath(abc.Traversable):
+        """
+        Path tied to a module spec.
+        Can be read and exposes the resource reader children.
+        """
+
+        def __init__(self, spec, reader):
+            self._spec = spec
+            self._reader = reader
+
+        def iterdir(self):
+            if not self._reader:
+                return iter(())
+            return iter(
+                CompatibilityFiles.ChildPath(self._reader, path)
+                for path in self._reader.contents()
+            )
+
+        def is_file(self):
+            return False
+
+        is_dir = is_file
+
+        def joinpath(self, other):
+            if not self._reader:
+                return CompatibilityFiles.OrphanPath(other)
+            return CompatibilityFiles.ChildPath(self._reader, other)
+
+        @property
+        def name(self):
+            return self._spec.name
+
+        def open(self, mode='r', *args, **kwargs):
+            return _io_wrapper(self._reader.open_resource(None), mode, *args, **kwargs)
+
+    class ChildPath(abc.Traversable):
+        """
+        Path tied to a resource reader child.
+        Can be read but doesn't expose any meaningful children.
+        """
+
+        def __init__(self, reader, name):
+            self._reader = reader
+            self._name = name
+
+        def iterdir(self):
+            return iter(())
+
+        def is_file(self):
+            return self._reader.is_resource(self.name)
+
+        def is_dir(self):
+            return not self.is_file()
+
+        def joinpath(self, other):
+            return CompatibilityFiles.OrphanPath(self.name, other)
+
+        @property
+        def name(self):
+            return self._name
+
+        def open(self, mode='r', *args, **kwargs):
+            return _io_wrapper(
+                self._reader.open_resource(self.name), mode, *args, **kwargs
+            )
+
+    class OrphanPath(abc.Traversable):
+        """
+        Orphan path, not tied to a module spec or resource reader.
+        Can't be read and doesn't expose any meaningful children.
+        """
+
+        def __init__(self, *path_parts):
+            if len(path_parts) < 1:
+                raise ValueError('Need at least one path part to construct a path')
+            self._path = path_parts
+
+        def iterdir(self):
+            return iter(())
+
+        def is_file(self):
+            return False
+
+        is_dir = is_file
+
+        def joinpath(self, other):
+            return CompatibilityFiles.OrphanPath(*self._path, other)
+
+        @property
+        def name(self):
+            return self._path[-1]
+
+        def open(self, mode='r', *args, **kwargs):
+            raise FileNotFoundError("Can't open orphan path")
+
+    def __init__(self, spec):
+        self.spec = spec
+
+    @property
+    def _reader(self):
+        with suppress(AttributeError):
+            return self.spec.loader.get_resource_reader(self.spec.name)
+
+    def _native(self):
+        """
+        Return the native reader if it supports files().
+        """
+        reader = self._reader
+        return reader if hasattr(reader, 'files') else self
+
+    def __getattr__(self, attr):
+        return getattr(self._reader, attr)
+
+    def files(self):
+        return CompatibilityFiles.SpecPath(self.spec, self._reader)
+
+
+def wrap_spec(package):
+    """
+    Construct a package spec with traversable compatibility
+    on the spec/loader/reader.
+    """
+    return SpecLoaderAdapter(package.__spec__, TraversableResourcesLoader)

lib/python3.10/site-packages/importlib_resources/_common.py

@@ -0,0 +1,211 @@
+import contextlib
+import functools
+import importlib
+import inspect
+import itertools
+import os
+import pathlib
+import tempfile
+import types
+import warnings
+from typing import Optional, Union, cast
+
+from .abc import ResourceReader, Traversable
+
+Package = Union[types.ModuleType, str]
+Anchor = Package
+
+
+def package_to_anchor(func):
+    """
+    Replace 'package' parameter as 'anchor' and warn about the change.
+
+    Other errors should fall through.
+
+    >>> files('a', 'b')
+    Traceback (most recent call last):
+    TypeError: files() takes from 0 to 1 positional arguments but 2 were given
+
+    Remove this compatibility in Python 3.14.
+    """
+    undefined = object()
+
+    @functools.wraps(func)
+    def wrapper(anchor=undefined, package=undefined):
+        if package is not undefined:
+            if anchor is not undefined:
+                return func(anchor, package)
+            warnings.warn(
+                "First parameter to files is renamed to 'anchor'",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            return func(package)
+        elif anchor is undefined:
+            return func()
+        return func(anchor)
+
+    return wrapper
+
+
+@package_to_anchor
+def files(anchor: Optional[Anchor] = None) -> Traversable:
+    """
+    Get a Traversable resource for an anchor.
+    """
+    return from_package(resolve(anchor))
+
+
+def get_resource_reader(package: types.ModuleType) -> Optional[ResourceReader]:
+    """
+    Return the package's loader if it's a ResourceReader.
+    """
+    # We can't use
+    # a issubclass() check here because apparently abc.'s __subclasscheck__()
+    # hook wants to create a weak reference to the object, but
+    # zipimport.zipimporter does not support weak references, resulting in a
+    # TypeError.  That seems terrible.
+    spec = package.__spec__
+    reader = getattr(spec.loader, 'get_resource_reader', None)  # type: ignore[union-attr]
+    if reader is None:
+        return None
+    return reader(spec.name)  # type: ignore[union-attr]
+
+
+@functools.singledispatch
+def resolve(cand: Optional[Anchor]) -> types.ModuleType:
+    return cast(types.ModuleType, cand)
+
+
+@resolve.register
+def _(cand: str) -> types.ModuleType:
+    return importlib.import_module(cand)
+
+
+@resolve.register
+def _(cand: None) -> types.ModuleType:
+    return resolve(_infer_caller().f_globals['__name__'])
+
+
+def _infer_caller():
+    """
+    Walk the stack and find the frame of the first caller not in this module.
+    """
+
+    def is_this_file(frame_info):
+        return frame_info.filename == stack[0].filename
+
+    def is_wrapper(frame_info):
+        return frame_info.function == 'wrapper'
+
+    stack = inspect.stack()
+    not_this_file = itertools.filterfalse(is_this_file, stack)
+    # also exclude 'wrapper' due to singledispatch in the call stack
+    callers = itertools.filterfalse(is_wrapper, not_this_file)
+    return next(callers).frame
+
+
+def from_package(package: types.ModuleType):
+    """
+    Return a Traversable object for the given package.
+
+    """
+    # deferred for performance (python/cpython#109829)
+    from .future.adapters import wrap_spec
+
+    spec = wrap_spec(package)
+    reader = spec.loader.get_resource_reader(spec.name)
+    return reader.files()
+
+
+@contextlib.contextmanager
+def _tempfile(
+    reader,
+    suffix='',
+    # gh-93353: Keep a reference to call os.remove() in late Python
+    # finalization.
+    *,
+    _os_remove=os.remove,
+):
+    # Not using tempfile.NamedTemporaryFile as it leads to deeper 'try'
+    # blocks due to the need to close the temporary file to work on Windows
+    # properly.
+    fd, raw_path = tempfile.mkstemp(suffix=suffix)
+    try:
+        try:
+            os.write(fd, reader())
+        finally:
+            os.close(fd)
+        del reader
+        yield pathlib.Path(raw_path)
+    finally:
+        try:
+            _os_remove(raw_path)
+        except FileNotFoundError:
+            pass
+
+
+def _temp_file(path):
+    return _tempfile(path.read_bytes, suffix=path.name)
+
+
+def _is_present_dir(path: Traversable) -> bool:
+    """
+    Some Traversables implement ``is_dir()`` to raise an
+    exception (i.e. ``FileNotFoundError``) when the
+    directory doesn't exist. This function wraps that call
+    to always return a boolean and only return True
+    if there's a dir and it exists.
+    """
+    with contextlib.suppress(FileNotFoundError):
+        return path.is_dir()
+    return False
+
+
+@functools.singledispatch
+def as_file(path):
+    """
+    Given a Traversable object, return that object as a
+    path on the local file system in a context manager.
+    """
+    return _temp_dir(path) if _is_present_dir(path) else _temp_file(path)
+
+
+@as_file.register(pathlib.Path)
+@contextlib.contextmanager
+def _(path):
+    """
+    Degenerate behavior for pathlib.Path objects.
+    """
+    yield path
+
+
+@contextlib.contextmanager
+def _temp_path(dir: tempfile.TemporaryDirectory):
+    """
+    Wrap tempfile.TemporaryDirectory to return a pathlib object.
+    """
+    with dir as result:
+        yield pathlib.Path(result)
+
+
+@contextlib.contextmanager
+def _temp_dir(path):
+    """
+    Given a traversable dir, recursively replicate the whole tree
+    to the file system in a context manager.
+    """
+    assert path.is_dir()
+    with _temp_path(tempfile.TemporaryDirectory()) as temp_dir:
+        yield _write_contents(temp_dir, path)
+
+
+def _write_contents(target, source):
+    child = target.joinpath(source.name)
+    if source.is_dir():
+        child.mkdir()
+        for item in source.iterdir():
+            _write_contents(child, item)
+    else:
+        child.write_bytes(source.read_bytes())
+    return child

lib/python3.10/site-packages/importlib_resources/_functional.py

@@ -0,0 +1,84 @@
+"""Simplified function-based API for importlib.resources"""
+
+import warnings
+
+from ._common import as_file, files
+from .abc import TraversalError
+
+_MISSING = object()
+
+
+def open_binary(anchor, *path_names):
+    """Open for binary reading the *resource* within *package*."""
+    return _get_resource(anchor, path_names).open('rb')
+
+
+def open_text(anchor, *path_names, encoding=_MISSING, errors='strict'):
+    """Open for text reading the *resource* within *package*."""
+    encoding = _get_encoding_arg(path_names, encoding)
+    resource = _get_resource(anchor, path_names)
+    return resource.open('r', encoding=encoding, errors=errors)
+
+
+def read_binary(anchor, *path_names):
+    """Read and return contents of *resource* within *package* as bytes."""
+    return _get_resource(anchor, path_names).read_bytes()
+
+
+def read_text(anchor, *path_names, encoding=_MISSING, errors='strict'):
+    """Read and return contents of *resource* within *package* as str."""
+    encoding = _get_encoding_arg(path_names, encoding)
+    resource = _get_resource(anchor, path_names)
+    return resource.read_text(encoding=encoding, errors=errors)
+
+
+def path(anchor, *path_names):
+    """Return the path to the *resource* as an actual file system path."""
+    return as_file(_get_resource(anchor, path_names))
+
+
+def is_resource(anchor, *path_names):
+    """Return ``True`` if there is a resource named *name* in the package,
+
+    Otherwise returns ``False``.
+    """
+    try:
+        return _get_resource(anchor, path_names).is_file()
+    except TraversalError:
+        return False
+
+
+def contents(anchor, *path_names):
+    """Return an iterable over the named resources within the package.
+
+    The iterable returns :class:`str` resources (e.g. files).
+    The iterable does not recurse into subdirectories.
+    """
+    warnings.warn(
+        "importlib.resources.contents is deprecated. "
+        "Use files(anchor).iterdir() instead.",
+        DeprecationWarning,
+        stacklevel=1,
+    )
+    return (resource.name for resource in _get_resource(anchor, path_names).iterdir())
+
+
+def _get_encoding_arg(path_names, encoding):
+    # For compatibility with versions where *encoding* was a positional
+    # argument, it needs to be given explicitly when there are multiple
+    # *path_names*.
+    # This limitation can be removed in Python 3.15.
+    if encoding is _MISSING:
+        if len(path_names) > 1:
+            raise TypeError(
+                "'encoding' argument required with multiple path names",
+            )
+        else:
+            return 'utf-8'
+    return encoding
+
+
+def _get_resource(anchor, path_names):
+    if anchor is None:
+        raise TypeError("anchor must be module or string, got None")
+    return files(anchor).joinpath(*path_names)

lib/python3.10/site-packages/importlib_resources/_itertools.py

@@ -0,0 +1,38 @@
+# from more_itertools 9.0
+def only(iterable, default=None, too_long=None):
+    """If *iterable* has only one item, return it.
+    If it has zero items, return *default*.
+    If it has more than one item, raise the exception given by *too_long*,
+    which is ``ValueError`` by default.
+    >>> only([], default='missing')
+    'missing'
+    >>> only([1])
+    1
+    >>> only([1, 2])  # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+    ...
+    ValueError: Expected exactly one item in iterable, but got 1, 2,
+     and perhaps more.'
+    >>> only([1, 2], too_long=TypeError)  # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+    ...
+    TypeError
+    Note that :func:`only` attempts to advance *iterable* twice to ensure there
+    is only one item.  See :func:`spy` or :func:`peekable` to check
+    iterable contents less destructively.
+    """
+    it = iter(iterable)
+    first_value = next(it, default)
+
+    try:
+        second_value = next(it)
+    except StopIteration:
+        pass
+    else:
+        msg = (
+            'Expected exactly one item in iterable, but got {!r}, {!r}, '
+            'and perhaps more.'.format(first_value, second_value)
+        )
+        raise too_long or ValueError(msg)
+
+    return first_value

lib/python3.10/site-packages/importlib_resources/abc.py

@@ -0,0 +1,193 @@
+import abc
+import itertools
+import os
+import pathlib
+from typing import (
+    Any,
+    BinaryIO,
+    Iterable,
+    Iterator,
+    NoReturn,
+    Literal,
+    Optional,
+    Protocol,
+    Text,
+    TextIO,
+    Union,
+    overload,
+    runtime_checkable,
+)
+
+StrPath = Union[str, os.PathLike[str]]
+
+__all__ = ["ResourceReader", "Traversable", "TraversableResources"]
+
+
+class ResourceReader(metaclass=abc.ABCMeta):
+    """Abstract base class for loaders to provide resource reading support."""
+
+    @abc.abstractmethod
+    def open_resource(self, resource: Text) -> BinaryIO:
+        """Return an opened, file-like object for binary reading.
+
+        The 'resource' argument is expected to represent only a file name.
+        If the resource cannot be found, FileNotFoundError is raised.
+        """
+        # This deliberately raises FileNotFoundError instead of
+        # NotImplementedError so that if this method is accidentally called,
+        # it'll still do the right thing.
+        raise FileNotFoundError
+
+    @abc.abstractmethod
+    def resource_path(self, resource: Text) -> Text:
+        """Return the file system path to the specified resource.
+
+        The 'resource' argument is expected to represent only a file name.
+        If the resource does not exist on the file system, raise
+        FileNotFoundError.
+        """
+        # This deliberately raises FileNotFoundError instead of
+        # NotImplementedError so that if this method is accidentally called,
+        # it'll still do the right thing.
+        raise FileNotFoundError
+
+    @abc.abstractmethod
+    def is_resource(self, path: Text) -> bool:
+        """Return True if the named 'path' is a resource.
+
+        Files are resources, directories are not.
+        """
+        raise FileNotFoundError
+
+    @abc.abstractmethod
+    def contents(self) -> Iterable[str]:
+        """Return an iterable of entries in `package`."""
+        raise FileNotFoundError
+
+
+class TraversalError(Exception):
+    pass
+
+
+@runtime_checkable
+class Traversable(Protocol):
+    """
+    An object with a subset of pathlib.Path methods suitable for
+    traversing directories and opening files.
+
+    Any exceptions that occur when accessing the backing resource
+    may propagate unaltered.
+    """
+
+    @abc.abstractmethod
+    def iterdir(self) -> Iterator["Traversable"]:
+        """
+        Yield Traversable objects in self
+        """
+
+    def read_bytes(self) -> bytes:
+        """
+        Read contents of self as bytes
+        """
+        with self.open('rb') as strm:
+            return strm.read()
+
+    def read_text(
+        self, encoding: Optional[str] = None, errors: Optional[str] = None
+    ) -> str:
+        """
+        Read contents of self as text
+        """
+        with self.open(encoding=encoding, errors=errors) as strm:
+            return strm.read()
+
+    @abc.abstractmethod
+    def is_dir(self) -> bool:
+        """
+        Return True if self is a directory
+        """
+
+    @abc.abstractmethod
+    def is_file(self) -> bool:
+        """
+        Return True if self is a file
+        """
+
+    def joinpath(self, *descendants: StrPath) -> "Traversable":
+        """
+        Return Traversable resolved with any descendants applied.
+
+        Each descendant should be a path segment relative to self
+        and each may contain multiple levels separated by
+        ``posixpath.sep`` (``/``).
+        """
+        if not descendants:
+            return self
+        names = itertools.chain.from_iterable(
+            path.parts for path in map(pathlib.PurePosixPath, descendants)
+        )
+        target = next(names)
+        matches = (
+            traversable for traversable in self.iterdir() if traversable.name == target
+        )
+        try:
+            match = next(matches)
+        except StopIteration:
+            raise TraversalError(
+                "Target not found during traversal.", target, list(names)
+            )
+        return match.joinpath(*names)
+
+    def __truediv__(self, child: StrPath) -> "Traversable":
+        """
+        Return Traversable child in self
+        """
+        return self.joinpath(child)
+
+    @overload
+    def open(self, mode: Literal['r'] = 'r', *args: Any, **kwargs: Any) -> TextIO: ...
+
+    @overload
+    def open(self, mode: Literal['rb'], *args: Any, **kwargs: Any) -> BinaryIO: ...
+
+    @abc.abstractmethod
+    def open(
+        self, mode: str = 'r', *args: Any, **kwargs: Any
+    ) -> Union[TextIO, BinaryIO]:
+        """
+        mode may be 'r' or 'rb' to open as text or binary. Return a handle
+        suitable for reading (same as pathlib.Path.open).
+
+        When opening as text, accepts encoding parameters such as those
+        accepted by io.TextIOWrapper.
+        """
+
+    @property
+    @abc.abstractmethod
+    def name(self) -> str:
+        """
+        The base name of this object without any parent references.
+        """
+
+
+class TraversableResources(ResourceReader):
+    """
+    The required interface for providing traversable
+    resources.
+    """
+
+    @abc.abstractmethod
+    def files(self) -> "Traversable":
+        """Return a Traversable object for the loaded package."""
+
+    def open_resource(self, resource: StrPath) -> BinaryIO:
+        return self.files().joinpath(resource).open('rb')
+
+    def resource_path(self, resource: Any) -> NoReturn:
+        raise FileNotFoundError(resource)
+
+    def is_resource(self, path: StrPath) -> bool:
+        return self.files().joinpath(path).is_file()
+
+    def contents(self) -> Iterator[str]:
+        return (item.name for item in self.files().iterdir())

lib/python3.10/site-packages/importlib_resources/readers.py

@@ -0,0 +1,202 @@
+from __future__ import annotations
+
+import collections
+import contextlib
+import itertools
+import operator
+import pathlib
+import re
+import warnings
+from collections.abc import Iterator
+
+from . import abc
+from ._itertools import only
+from .compat.py39 import ZipPath
+
+
+def remove_duplicates(items):
+    return iter(collections.OrderedDict.fromkeys(items))
+
+
+class FileReader(abc.TraversableResources):
+    def __init__(self, loader):
+        self.path = pathlib.Path(loader.path).parent
+
+    def resource_path(self, resource):
+        """
+        Return the file system path to prevent
+        `resources.path()` from creating a temporary
+        copy.
+        """
+        return str(self.path.joinpath(resource))
+
+    def files(self):
+        return self.path
+
+
+class ZipReader(abc.TraversableResources):
+    def __init__(self, loader, module):
+        self.prefix = loader.prefix.replace('\\', '/')
+        if loader.is_package(module):
+            _, _, name = module.rpartition('.')
+            self.prefix += name + '/'
+        self.archive = loader.archive
+
+    def open_resource(self, resource):
+        try:
+            return super().open_resource(resource)
+        except KeyError as exc:
+            raise FileNotFoundError(exc.args[0])
+
+    def is_resource(self, path):
+        """
+        Workaround for `zipfile.Path.is_file` returning true
+        for non-existent paths.
+        """
+        target = self.files().joinpath(path)
+        return target.is_file() and target.exists()
+
+    def files(self):
+        return ZipPath(self.archive, self.prefix)
+
+
+class MultiplexedPath(abc.Traversable):
+    """
+    Given a series of Traversable objects, implement a merged
+    version of the interface across all objects. Useful for
+    namespace packages which may be multihomed at a single
+    name.
+    """
+
+    def __init__(self, *paths):
+        self._paths = list(map(_ensure_traversable, remove_duplicates(paths)))
+        if not self._paths:
+            message = 'MultiplexedPath must contain at least one path'
+            raise FileNotFoundError(message)
+        if not all(path.is_dir() for path in self._paths):
+            raise NotADirectoryError('MultiplexedPath only supports directories')
+
+    def iterdir(self):
+        children = (child for path in self._paths for child in path.iterdir())
+        by_name = operator.attrgetter('name')
+        groups = itertools.groupby(sorted(children, key=by_name), key=by_name)
+        return map(self._follow, (locs for name, locs in groups))
+
+    def read_bytes(self):
+        raise FileNotFoundError(f'{self} is not a file')
+
+    def read_text(self, *args, **kwargs):
+        raise FileNotFoundError(f'{self} is not a file')
+
+    def is_dir(self):
+        return True
+
+    def is_file(self):
+        return False
+
+    def joinpath(self, *descendants):
+        try:
+            return super().joinpath(*descendants)
+        except abc.TraversalError:
+            # One of the paths did not resolve (a directory does not exist).
+            # Just return something that will not exist.
+            return self._paths[0].joinpath(*descendants)
+
+    @classmethod
+    def _follow(cls, children):
+        """
+        Construct a MultiplexedPath if needed.
+
+        If children contains a sole element, return it.
+        Otherwise, return a MultiplexedPath of the items.
+        Unless one of the items is not a Directory, then return the first.
+        """
+        subdirs, one_dir, one_file = itertools.tee(children, 3)
+
+        try:
+            return only(one_dir)
+        except ValueError:
+            try:
+                return cls(*subdirs)
+            except NotADirectoryError:
+                return next(one_file)
+
+    def open(self, *args, **kwargs):
+        raise FileNotFoundError(f'{self} is not a file')
+
+    @property
+    def name(self):
+        return self._paths[0].name
+
+    def __repr__(self):
+        paths = ', '.join(f"'{path}'" for path in self._paths)
+        return f'MultiplexedPath({paths})'
+
+
+class NamespaceReader(abc.TraversableResources):
+    def __init__(self, namespace_path):
+        if 'NamespacePath' not in str(namespace_path):
+            raise ValueError('Invalid path')
+        self.path = MultiplexedPath(*filter(bool, map(self._resolve, namespace_path)))
+
+    @classmethod
+    def _resolve(cls, path_str) -> abc.Traversable | None:
+        r"""
+        Given an item from a namespace path, resolve it to a Traversable.
+
+        path_str might be a directory on the filesystem or a path to a
+        zipfile plus the path within the zipfile, e.g. ``/foo/bar`` or
+        ``/foo/baz.zip/inner_dir`` or ``foo\baz.zip\inner_dir\sub``.
+
+        path_str might also be a sentinel used by editable packages to
+        trigger other behaviors (see python/importlib_resources#311).
+        In that case, return None.
+        """
+        dirs = (cand for cand in cls._candidate_paths(path_str) if cand.is_dir())
+        return next(dirs, None)
+
+    @classmethod
+    def _candidate_paths(cls, path_str: str) -> Iterator[abc.Traversable]:
+        yield pathlib.Path(path_str)
+        yield from cls._resolve_zip_path(path_str)
+
+    @staticmethod
+    def _resolve_zip_path(path_str: str):
+        for match in reversed(list(re.finditer(r'[\\/]', path_str))):
+            with contextlib.suppress(
+                FileNotFoundError,
+                IsADirectoryError,
+                NotADirectoryError,
+                PermissionError,
+            ):
+                inner = path_str[match.end() :].replace('\\', '/') + '/'
+                yield ZipPath(path_str[: match.start()], inner.lstrip('/'))
+
+    def resource_path(self, resource):
+        """
+        Return the file system path to prevent
+        `resources.path()` from creating a temporary
+        copy.
+        """
+        return str(self.path.joinpath(resource))
+
+    def files(self):
+        return self.path
+
+
+def _ensure_traversable(path):
+    """
+    Convert deprecated string arguments to traversables (pathlib.Path).
+
+    Remove with Python 3.15.
+    """
+    if not isinstance(path, str):
+        return path
+
+    warnings.warn(
+        "String arguments are deprecated. Pass a Traversable instead.",
+        DeprecationWarning,
+        stacklevel=3,
+    )
+
+    return pathlib.Path(path)

lib/python3.10/site-packages/importlib_resources/simple.py

@@ -0,0 +1,106 @@
+"""
+Interface adapters for low-level readers.
+"""
+
+import abc
+import io
+import itertools
+from typing import BinaryIO, List
+
+from .abc import Traversable, TraversableResources
+
+
+class SimpleReader(abc.ABC):
+    """
+    The minimum, low-level interface required from a resource
+    provider.
+    """
+
+    @property
+    @abc.abstractmethod
+    def package(self) -> str:
+        """
+        The name of the package for which this reader loads resources.
+        """
+
+    @abc.abstractmethod
+    def children(self) -> List['SimpleReader']:
+        """
+        Obtain an iterable of SimpleReader for available
+        child containers (e.g. directories).
+        """
+
+    @abc.abstractmethod
+    def resources(self) -> List[str]:
+        """
+        Obtain available named resources for this virtual package.
+        """
+
+    @abc.abstractmethod
+    def open_binary(self, resource: str) -> BinaryIO:
+        """
+        Obtain a File-like for a named resource.
+        """
+
+    @property
+    def name(self):
+        return self.package.split('.')[-1]
+
+
+class ResourceContainer(Traversable):
+    """
+    Traversable container for a package's resources via its reader.
+    """
+
+    def __init__(self, reader: SimpleReader):
+        self.reader = reader
+
+    def is_dir(self):
+        return True
+
+    def is_file(self):
+        return False
+
+    def iterdir(self):
+        files = (ResourceHandle(self, name) for name in self.reader.resources)
+        dirs = map(ResourceContainer, self.reader.children())
+        return itertools.chain(files, dirs)
+
+    def open(self, *args, **kwargs):
+        raise IsADirectoryError()
+
+
+class ResourceHandle(Traversable):
+    """
+    Handle to a named resource in a ResourceReader.
+    """
+
+    def __init__(self, parent: ResourceContainer, name: str):
+        self.parent = parent
+        self.name = name  # type: ignore[misc]
+
+    def is_file(self):
+        return True
+
+    def is_dir(self):
+        return False
+
+    def open(self, mode='r', *args, **kwargs):
+        stream = self.parent.reader.open_binary(self.name)
+        if 'b' not in mode:
+            stream = io.TextIOWrapper(stream, *args, **kwargs)
+        return stream
+
+    def joinpath(self, name):
+        raise RuntimeError("Cannot traverse into a resource")
+
+
+class TraversableReader(TraversableResources, SimpleReader):
+    """
+    A TraversableResources based on SimpleReader. Resource providers
+    may derive from this class to provide the TraversableResources
+    interface by supplying the SimpleReader interface.
+    """
+
+    def files(self):
+        return ResourceContainer(self)

lib/python3.10/site-packages/importlib_resources/tests/test_contents.py

@@ -0,0 +1,39 @@
+import unittest
+
+import importlib_resources as resources
+
+from . import util
+
+
+class ContentsTests:
+    expected = {
+        '__init__.py',
+        'binary.file',
+        'subdirectory',
+        'utf-16.file',
+        'utf-8.file',
+    }
+
+    def test_contents(self):
+        contents = {path.name for path in resources.files(self.data).iterdir()}
+        assert self.expected <= contents
+
+
+class ContentsDiskTests(ContentsTests, util.DiskSetup, unittest.TestCase):
+    pass
+
+
+class ContentsZipTests(ContentsTests, util.ZipSetup, unittest.TestCase):
+    pass
+
+
+class ContentsNamespaceTests(ContentsTests, util.DiskSetup, unittest.TestCase):
+    MODULE = 'namespacedata01'
+
+    expected = {
+        # no __init__ because of namespace design
+        'binary.file',
+        'subdirectory',
+        'utf-16.file',
+        'utf-8.file',
+    }