Add files using upload-large-folder tool

ckpts/universal/global_step20/zero/17.attention.query_key_value.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8289f624651c26b48ff5a21d447fab47c63817b5433b361bf73f3038133ac12f
+size 50332843

ckpts/universal/global_step20/zero/24.post_attention_layernorm.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8ba335e43797248a530e3eb0108f602b6d515f1c55ae0ec0bbc572f8f75e4cf8
+size 9372

ckpts/universal/global_step20/zero/24.post_attention_layernorm.weight/exp_avg_sq.pt

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

ckpts/universal/global_step20/zero/24.post_attention_layernorm.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:953100e3eaba559ce7382929b9d52d98680a68054aeb16930fdc0278b8db52af
+size 9293

venv/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()

venv/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'."
+                )

venv/lib/python3.10/site-packages/datasets/commands/convert_to_parquet.py

@@ -0,0 +1,156 @@
+import time
+from argparse import ArgumentParser
+from typing import Optional
+
+from huggingface_hub import HfApi, create_branch, get_repo_discussions
+
+from datasets import get_dataset_config_names, get_dataset_default_config_name, load_dataset
+from datasets.commands import BaseDatasetsCLICommand
+
+
+def _command_factory(args):
+    return ConvertToParquetCommand(
+        args.dataset_id,
+        args.token,
+        args.revision,
+        args.trust_remote_code,
+    )
+
+
+class ConvertToParquetCommand(BaseDatasetsCLICommand):
+    @staticmethod
+    def register_subcommand(parser):
+        parser: ArgumentParser = parser.add_parser("convert_to_parquet", help="Convert dataset to Parquet")
+        parser.add_argument("dataset_id", help="source dataset ID")
+        parser.add_argument("--token", help="access token to the Hugging Face Hub")
+        parser.add_argument("--revision", help="source revision")
+        parser.add_argument(
+            "--trust_remote_code", action="store_true", help="whether to trust the code execution of the load script"
+        )
+        parser.set_defaults(func=_command_factory)
+
+    def __init__(
+        self,
+        dataset_id: str,
+        token: Optional[str],
+        revision: Optional[str],
+        trust_remote_code: bool,
+    ):
+        self._dataset_id = dataset_id
+        self._token = token
+        self._revision = revision
+        self._trust_remote_code = trust_remote_code
+
+    def run(self) -> None:
+        dataset_id = self._dataset_id
+        token = self._token
+        revision = self._revision
+        trust_remote_code = self._trust_remote_code
+        print(f"{dataset_id}")
+        configs = get_dataset_config_names(
+            dataset_id, token=token, revision=revision, trust_remote_code=trust_remote_code
+        )
+        print(f"{configs = }")
+        default_config = get_dataset_default_config_name(
+            dataset_id, token=token, revision=revision, trust_remote_code=trust_remote_code
+        )
+        print(f"{default_config = }")
+        if default_config:
+            config = default_config
+            configs.remove(default_config)
+        else:
+            config = configs.pop(0)
+        print(f"{config = }")
+        dataset = load_dataset(dataset_id, config, revision=revision, trust_remote_code=trust_remote_code)
+        commit_info = dataset.push_to_hub(
+            dataset_id,
+            config_name=config,
+            commit_message="Convert dataset to Parquet",
+            commit_description="Convert dataset to Parquet.",
+            create_pr=True,
+            token=token,
+            set_default=default_config is not None,
+        )
+        time.sleep(5)
+        if commit_info:
+            pr_revision, pr_url = commit_info.pr_revision, commit_info.pr_url
+        else:
+            pr_revision, pr_url = infer_pr(dataset_id, token=token)
+        for config in configs:
+            print(f"{config = }")
+            dataset = load_dataset(dataset_id, config, revision=revision, trust_remote_code=trust_remote_code)
+            dataset.push_to_hub(
+                dataset_id,
+                config_name=config,
+                commit_message=f"Add {config} data files",
+                revision=pr_revision,
+                token=token,
+            )
+            time.sleep(5)
+        delete_files(dataset_id, revision=pr_revision, token=token)
+        if not revision:
+            create_branch(dataset_id, branch="script", repo_type="dataset", token=token, exist_ok=True)
+        print(f"You can find your PR to convert the dataset to Parquet at: {pr_url}")
+
+
+def infer_pr(dataset_id, token=None):
+    discussions = get_repo_discussions(dataset_id, repo_type="dataset", token=token)
+    prs = [discussion for discussion in discussions if discussion.is_pull_request and discussion.status == "open"]
+    pr = sorted(prs, key=lambda pr: pr.num)[-1]
+    return pr.git_reference, pr.url
+
+
+def delete_files(dataset_id, revision=None, token=None):
+    dataset_name = dataset_id.split("/")[-1]
+    hf_api = HfApi(token=token)
+    repo_files = hf_api.list_repo_files(
+        dataset_id,
+        repo_type="dataset",
+    )
+    if repo_files:
+        legacy_json_file = []
+        python_files = []
+        data_files = []
+        for filename in repo_files:
+            if filename in {".gitattributes", "README.md"}:
+                continue
+            elif filename == f"{dataset_name}.py":
+                hf_api.delete_file(
+                    filename,
+                    dataset_id,
+                    repo_type="dataset",
+                    revision=revision,
+                    commit_message="Delete loading script",
+                )
+            elif filename == "dataset_infos.json":
+                legacy_json_file.append(filename)
+            elif filename.endswith(".py"):
+                python_files.append(filename)
+            else:
+                data_files.append(filename)
+        if legacy_json_file:
+            hf_api.delete_file(
+                "dataset_infos.json",
+                dataset_id,
+                repo_type="dataset",
+                revision=revision,
+                commit_message="Delete legacy dataset_infos.json",
+            )
+        if python_files:
+            for filename in python_files:
+                hf_api.delete_file(
+                    filename,
+                    dataset_id,
+                    repo_type="dataset",
+                    revision=revision,
+                    commit_message="Delete loading script auxiliary file",
+                )
+        if data_files:
+            for filename in data_files:
+                hf_api.delete_file(
+                    filename,
+                    dataset_id,
+                    repo_type="dataset",
+                    revision=revision,
+                    commit_message="Delete data file",
+                )

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

@@ -0,0 +1,45 @@
+#!/usr/bin/env python
+from argparse import ArgumentParser
+
+from datasets.commands.convert import ConvertCommand
+from datasets.commands.convert_to_parquet import ConvertToParquetCommand
+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)
+    ConvertToParquetCommand.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()

venv/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)

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

@@ -0,0 +1,41 @@
+import platform
+from argparse import ArgumentParser
+
+import fsspec
+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__,
+            "`fsspec` version": fsspec.__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"

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

@@ -0,0 +1,168 @@
+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.deprecation_utils import deprecated
+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,
+    )
+
+
+@deprecated(
+    "`BeamBasedBuilder` and `datasets-cli run_beam` are deprecated and will be removed in v3.0.0. Please use `GeneratorBasedBuilder` or `ArrowBasedBuilder` instead."
+)
+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,
+            )
+            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}")

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

@@ -0,0 +1,201 @@
+import logging
+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.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,
+        args.num_proc,
+    )
+
+
+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",
+        )
+        test_parser.add_argument("--num_proc", type=int, default=None, help="Number of processes")
+        # 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,
+        num_proc: int,
+    ):
+        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
+        self._num_proc = num_proc
+        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):
+        logging.getLogger("filelock").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,
+                num_proc=self._num_proc,
+            )
+            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(), datasets.config.REPOCARD_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
+                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, datasets.config.REPOCARD_FILENAME)
+                    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.")

venv/lib/python3.10/site-packages/datasets/formatting/__init__.py

@@ -0,0 +1,139 @@
+# Copyright 2020 The HuggingFace Datasets Authors and the TensorFlow Datasets Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# ruff: noqa
+
+from typing import Dict, List, Optional, Type
+
+from .. import config
+from ..utils import logging
+from .formatting import (
+    ArrowFormatter,
+    CustomFormatter,
+    Formatter,
+    PandasFormatter,
+    PythonFormatter,
+    TensorFormatter,
+    format_table,
+    query_table,
+)
+from .np_formatter import NumpyFormatter
+
+
+logger = logging.get_logger(__name__)
+
+_FORMAT_TYPES: Dict[Optional[str], Type[Formatter]] = {}
+_FORMAT_TYPES_ALIASES: Dict[Optional[str], str] = {}
+_FORMAT_TYPES_ALIASES_UNAVAILABLE: Dict[Optional[str], Exception] = {}
+
+
+def _register_formatter(
+    formatter_cls: type,
+    format_type: Optional[str],
+    aliases: Optional[List[str]] = None,
+):
+    """
+    Register a Formatter object using a name and optional aliases.
+    This function must be used on a Formatter class.
+    """
+    aliases = aliases if aliases is not None else []
+    if format_type in _FORMAT_TYPES:
+        logger.warning(
+            f"Overwriting format type '{format_type}' ({_FORMAT_TYPES[format_type].__name__} -> {formatter_cls.__name__})"
+        )
+    _FORMAT_TYPES[format_type] = formatter_cls
+    for alias in set(aliases + [format_type]):
+        if alias in _FORMAT_TYPES_ALIASES:
+            logger.warning(
+                f"Overwriting format type alias '{alias}' ({_FORMAT_TYPES_ALIASES[alias]} -> {format_type})"
+            )
+        _FORMAT_TYPES_ALIASES[alias] = format_type
+
+
+def _register_unavailable_formatter(
+    unavailable_error: Exception, format_type: Optional[str], aliases: Optional[List[str]] = None
+):
+    """
+    Register an unavailable Formatter object using a name and optional aliases.
+    This function must be used on an Exception object that is raised when trying to get the unavailable formatter.
+    """
+    aliases = aliases if aliases is not None else []
+    for alias in set(aliases + [format_type]):
+        _FORMAT_TYPES_ALIASES_UNAVAILABLE[alias] = unavailable_error
+
+
+# Here we define all the available formatting functions that can be used by `Dataset.set_format`
+_register_formatter(PythonFormatter, None, aliases=["python"])
+_register_formatter(ArrowFormatter, "arrow", aliases=["pa", "pyarrow"])
+_register_formatter(NumpyFormatter, "numpy", aliases=["np"])
+_register_formatter(PandasFormatter, "pandas", aliases=["pd"])
+_register_formatter(CustomFormatter, "custom")
+
+if config.POLARS_AVAILABLE:
+    from .polars_formatter import PolarsFormatter
+
+    _register_formatter(PolarsFormatter, "polars", aliases=["pl"])
+else:
+    _polars_error = ValueError("Polars needs to be installed to be able to return Polars dataframes.")
+    _register_unavailable_formatter(_polars_error, "polars", aliases=["pl"])
+
+if config.TORCH_AVAILABLE:
+    from .torch_formatter import TorchFormatter
+
+    _register_formatter(TorchFormatter, "torch", aliases=["pt", "pytorch"])
+else:
+    _torch_error = ValueError("PyTorch needs to be installed to be able to return PyTorch tensors.")
+    _register_unavailable_formatter(_torch_error, "torch", aliases=["pt", "pytorch"])
+
+if config.TF_AVAILABLE:
+    from .tf_formatter import TFFormatter
+
+    _register_formatter(TFFormatter, "tensorflow", aliases=["tf"])
+else:
+    _tf_error = ValueError("Tensorflow needs to be installed to be able to return Tensorflow tensors.")
+    _register_unavailable_formatter(_tf_error, "tensorflow", aliases=["tf"])
+
+if config.JAX_AVAILABLE:
+    from .jax_formatter import JaxFormatter
+
+    _register_formatter(JaxFormatter, "jax", aliases=[])
+else:
+    _jax_error = ValueError("JAX needs to be installed to be able to return JAX arrays.")
+    _register_unavailable_formatter(_jax_error, "jax", aliases=[])
+
+
+def get_format_type_from_alias(format_type: Optional[str]) -> Optional[str]:
+    """If the given format type is a known alias, then return its main type name. Otherwise return the type with no change."""
+    if format_type in _FORMAT_TYPES_ALIASES:
+        return _FORMAT_TYPES_ALIASES[format_type]
+    else:
+        return format_type
+
+
+def get_formatter(format_type: Optional[str], **format_kwargs) -> Formatter:
+    """
+    Factory function to get a Formatter given its type name and keyword arguments.
+    A formatter is an object that extracts and formats data from pyarrow table.
+    It defines the formatting for rows, colums and batches.
+    If the formatter for a given type name doesn't exist or is not available, an error is raised.
+    """
+    format_type = get_format_type_from_alias(format_type)
+    if format_type in _FORMAT_TYPES:
+        return _FORMAT_TYPES[format_type](**format_kwargs)
+    if format_type in _FORMAT_TYPES_ALIASES_UNAVAILABLE:
+        raise _FORMAT_TYPES_ALIASES_UNAVAILABLE[format_type]
+    else:
+        raise ValueError(
+            f"Return type should be None or selected in {list(type for type in _FORMAT_TYPES.keys() if type != None)}, but got '{format_type}'"
+        )

venv/lib/python3.10/site-packages/datasets/formatting/formatting.py

@@ -0,0 +1,653 @@
+# Copyright 2020 The HuggingFace Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import operator
+from collections.abc import Mapping, MutableMapping
+from functools import partial
+
+# Lint as: python3
+from typing import Any, Callable, Dict, Generic, Iterable, List, Optional, TypeVar, Union
+
+import numpy as np
+import pandas as pd
+import pyarrow as pa
+from packaging import version
+
+from .. import config
+from ..features import Features
+from ..features.features import _ArrayXDExtensionType, _is_zero_copy_only, decode_nested_example, pandas_types_mapper
+from ..table import Table
+from ..utils.py_utils import no_op_if_value_is_null
+
+
+T = TypeVar("T")
+
+RowFormat = TypeVar("RowFormat")
+ColumnFormat = TypeVar("ColumnFormat")
+BatchFormat = TypeVar("BatchFormat")
+
+
+def _is_range_contiguous(key: range) -> bool:
+    return key.step == 1 and key.stop >= key.start
+
+
+def _raise_bad_key_type(key: Any):
+    raise TypeError(
+        f"Wrong key type: '{key}' of type '{type(key)}'. Expected one of int, slice, range, str or Iterable."
+    )
+
+
+def _query_table_with_indices_mapping(
+    table: Table, key: Union[int, slice, range, str, Iterable], indices: Table
+) -> pa.Table:
+    """
+    Query a pyarrow Table to extract the subtable that correspond to the given key.
+    The :obj:`indices` parameter corresponds to the indices mapping in case we cant to take into
+    account a shuffling or an indices selection for example.
+    The indices table must contain one column named "indices" of type uint64.
+    """
+    if isinstance(key, int):
+        key = indices.fast_slice(key % indices.num_rows, 1).column(0)[0].as_py()
+        return _query_table(table, key)
+    if isinstance(key, slice):
+        key = range(*key.indices(indices.num_rows))
+    if isinstance(key, range):
+        if _is_range_contiguous(key) and key.start >= 0:
+            return _query_table(
+                table, [i.as_py() for i in indices.fast_slice(key.start, key.stop - key.start).column(0)]
+            )
+        else:
+            pass  # treat as an iterable
+    if isinstance(key, str):
+        table = table.select([key])
+        return _query_table(table, indices.column(0).to_pylist())
+    if isinstance(key, Iterable):
+        return _query_table(table, [indices.fast_slice(i, 1).column(0)[0].as_py() for i in key])
+
+    _raise_bad_key_type(key)
+
+
+def _query_table(table: Table, key: Union[int, slice, range, str, Iterable]) -> pa.Table:
+    """
+    Query a pyarrow Table to extract the subtable that correspond to the given key.
+    """
+    if isinstance(key, int):
+        return table.fast_slice(key % table.num_rows, 1)
+    if isinstance(key, slice):
+        key = range(*key.indices(table.num_rows))
+    if isinstance(key, range):
+        if _is_range_contiguous(key) and key.start >= 0:
+            return table.fast_slice(key.start, key.stop - key.start)
+        else:
+            pass  # treat as an iterable
+    if isinstance(key, str):
+        return table.table.drop([column for column in table.column_names if column != key])
+    if isinstance(key, Iterable):
+        key = np.fromiter(key, np.int64)
+        if len(key) == 0:
+            return table.table.slice(0, 0)
+        # don't use pyarrow.Table.take even for pyarrow >=1.0 (see https://issues.apache.org/jira/browse/ARROW-9773)
+        return table.fast_gather(key % table.num_rows)
+
+    _raise_bad_key_type(key)
+
+
+def _is_array_with_nulls(pa_array: pa.Array) -> bool:
+    return pa_array.null_count > 0
+
+
+class BaseArrowExtractor(Generic[RowFormat, ColumnFormat, BatchFormat]):
+    """
+    Arrow extractor are used to extract data from pyarrow tables.
+    It makes it possible to extract rows, columns and batches.
+    These three extractions types have to be implemented.
+    """
+
+    def extract_row(self, pa_table: pa.Table) -> RowFormat:
+        raise NotImplementedError
+
+    def extract_column(self, pa_table: pa.Table) -> ColumnFormat:
+        raise NotImplementedError
+
+    def extract_batch(self, pa_table: pa.Table) -> BatchFormat:
+        raise NotImplementedError
+
+
+def _unnest(py_dict: Dict[str, List[T]]) -> Dict[str, T]:
+    """Return the first element of a batch (dict) as a row (dict)"""
+    return {key: array[0] for key, array in py_dict.items()}
+
+
+class SimpleArrowExtractor(BaseArrowExtractor[pa.Table, pa.Array, pa.Table]):
+    def extract_row(self, pa_table: pa.Table) -> pa.Table:
+        return pa_table
+
+    def extract_column(self, pa_table: pa.Table) -> pa.Array:
+        return pa_table.column(0)
+
+    def extract_batch(self, pa_table: pa.Table) -> pa.Table:
+        return pa_table
+
+
+class PythonArrowExtractor(BaseArrowExtractor[dict, list, dict]):
+    def extract_row(self, pa_table: pa.Table) -> dict:
+        return _unnest(pa_table.to_pydict())
+
+    def extract_column(self, pa_table: pa.Table) -> list:
+        return pa_table.column(0).to_pylist()
+
+    def extract_batch(self, pa_table: pa.Table) -> dict:
+        return pa_table.to_pydict()
+
+
+class NumpyArrowExtractor(BaseArrowExtractor[dict, np.ndarray, dict]):
+    def __init__(self, **np_array_kwargs):
+        self.np_array_kwargs = np_array_kwargs
+
+    def extract_row(self, pa_table: pa.Table) -> dict:
+        return _unnest(self.extract_batch(pa_table))
+
+    def extract_column(self, pa_table: pa.Table) -> np.ndarray:
+        return self._arrow_array_to_numpy(pa_table[pa_table.column_names[0]])
+
+    def extract_batch(self, pa_table: pa.Table) -> dict:
+        return {col: self._arrow_array_to_numpy(pa_table[col]) for col in pa_table.column_names}
+
+    def _arrow_array_to_numpy(self, pa_array: pa.Array) -> np.ndarray:
+        if isinstance(pa_array, pa.ChunkedArray):
+            if isinstance(pa_array.type, _ArrayXDExtensionType):
+                # don't call to_pylist() to preserve dtype of the fixed-size array
+                zero_copy_only = _is_zero_copy_only(pa_array.type.storage_dtype, unnest=True)
+                array: List = [
+                    row for chunk in pa_array.chunks for row in chunk.to_numpy(zero_copy_only=zero_copy_only)
+                ]
+            else:
+                zero_copy_only = _is_zero_copy_only(pa_array.type) and all(
+                    not _is_array_with_nulls(chunk) for chunk in pa_array.chunks
+                )
+                array: List = [
+                    row for chunk in pa_array.chunks for row in chunk.to_numpy(zero_copy_only=zero_copy_only)
+                ]
+        else:
+            if isinstance(pa_array.type, _ArrayXDExtensionType):
+                # don't call to_pylist() to preserve dtype of the fixed-size array
+                zero_copy_only = _is_zero_copy_only(pa_array.type.storage_dtype, unnest=True)
+                array: List = pa_array.to_numpy(zero_copy_only=zero_copy_only)
+            else:
+                zero_copy_only = _is_zero_copy_only(pa_array.type) and not _is_array_with_nulls(pa_array)
+                array: List = pa_array.to_numpy(zero_copy_only=zero_copy_only).tolist()
+        if len(array) > 0:
+            if any(
+                (isinstance(x, np.ndarray) and (x.dtype == object or x.shape != array[0].shape))
+                or (isinstance(x, float) and np.isnan(x))
+                for x in array
+            ):
+                return np.array(array, copy=False, dtype=object)
+        return np.array(array, copy=False)
+
+
+class PandasArrowExtractor(BaseArrowExtractor[pd.DataFrame, pd.Series, pd.DataFrame]):
+    def extract_row(self, pa_table: pa.Table) -> pd.DataFrame:
+        return pa_table.slice(length=1).to_pandas(types_mapper=pandas_types_mapper)
+
+    def extract_column(self, pa_table: pa.Table) -> pd.Series:
+        return pa_table.select([0]).to_pandas(types_mapper=pandas_types_mapper)[pa_table.column_names[0]]
+
+    def extract_batch(self, pa_table: pa.Table) -> pd.DataFrame:
+        return pa_table.to_pandas(types_mapper=pandas_types_mapper)
+
+
+class PythonFeaturesDecoder:
+    def __init__(self, features: Optional[Features]):
+        self.features = features
+
+    def decode_row(self, row: dict) -> dict:
+        return self.features.decode_example(row) if self.features else row
+
+    def decode_column(self, column: list, column_name: str) -> list:
+        return self.features.decode_column(column, column_name) if self.features else column
+
+    def decode_batch(self, batch: dict) -> dict:
+        return self.features.decode_batch(batch) if self.features else batch
+
+
+class PandasFeaturesDecoder:
+    def __init__(self, features: Optional[Features]):
+        self.features = features
+
+    def decode_row(self, row: pd.DataFrame) -> pd.DataFrame:
+        decode = (
+            {
+                column_name: no_op_if_value_is_null(partial(decode_nested_example, feature))
+                for column_name, feature in self.features.items()
+                if self.features._column_requires_decoding[column_name]
+            }
+            if self.features
+            else {}
+        )
+        if decode:
+            row[list(decode.keys())] = row.transform(decode)
+        return row
+
+    def decode_column(self, column: pd.Series, column_name: str) -> pd.Series:
+        decode = (
+            no_op_if_value_is_null(partial(decode_nested_example, self.features[column_name]))
+            if self.features and column_name in self.features and self.features._column_requires_decoding[column_name]
+            else None
+        )
+        if decode:
+            column = column.transform(decode)
+        return column
+
+    def decode_batch(self, batch: pd.DataFrame) -> pd.DataFrame:
+        return self.decode_row(batch)
+
+
+class LazyDict(MutableMapping):
+    """A dictionary backed by Arrow data. The values are formatted on-the-fly when accessing the dictionary."""
+
+    def __init__(self, pa_table: pa.Table, formatter: "Formatter"):
+        self.pa_table = pa_table
+        self.formatter = formatter
+
+        self.data = {key: None for key in pa_table.column_names}
+        self.keys_to_format = set(self.data.keys())
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, key):
+        value = self.data[key]
+        if key in self.keys_to_format:
+            value = self.format(key)
+            self.data[key] = value
+            self.keys_to_format.remove(key)
+        return value
+
+    def __setitem__(self, key, value):
+        if key in self.keys_to_format:
+            self.keys_to_format.remove(key)
+        self.data[key] = value
+
+    def __delitem__(self, key) -> None:
+        if key in self.keys_to_format:
+            self.keys_to_format.remove(key)
+        del self.data[key]
+
+    def __iter__(self):
+        return iter(self.data)
+
+    def __contains__(self, key):
+        return key in self.data
+
+    def __repr__(self):
+        self._format_all()
+        return repr(self.data)
+
+    if config.PY_VERSION >= version.parse("3.9"):
+        # merging with the union ("|") operator is supported in Python 3.9+
+
+        def __or__(self, other):
+            if isinstance(other, LazyDict):
+                inst = self.copy()
+                other = other.copy()
+                other._format_all()
+                inst.keys_to_format -= other.data.keys()
+                inst.data = inst.data | other.data
+                return inst
+            if isinstance(other, dict):
+                inst = self.copy()
+                inst.keys_to_format -= other.keys()
+                inst.data = inst.data | other
+                return inst
+            return NotImplemented
+
+        def __ror__(self, other):
+            if isinstance(other, LazyDict):
+                inst = self.copy()
+                other = other.copy()
+                other._format_all()
+                inst.keys_to_format -= other.data.keys()
+                inst.data = other.data | inst.data
+                return inst
+            if isinstance(other, dict):
+                inst = self.copy()
+                inst.keys_to_format -= other.keys()
+                inst.data = other | inst.data
+                return inst
+            return NotImplemented
+
+        def __ior__(self, other):
+            if isinstance(other, LazyDict):
+                other = other.copy()
+                other._format_all()
+                self.keys_to_format -= other.data.keys()
+                self.data |= other.data
+            else:
+                self.keys_to_format -= other.keys()
+                self.data |= other
+            return self
+
+    def __copy__(self):
+        # Identical to `UserDict.__copy__`
+        inst = self.__class__.__new__(self.__class__)
+        inst.__dict__.update(self.__dict__)
+        # Create a copy and avoid triggering descriptors
+        inst.__dict__["data"] = self.__dict__["data"].copy()
+        inst.__dict__["keys_to_format"] = self.__dict__["keys_to_format"].copy()
+        return inst
+
+    def copy(self):
+        import copy
+
+        return copy.copy(self)
+
+    @classmethod
+    def fromkeys(cls, iterable, value=None):
+        raise NotImplementedError
+
+    def format(self, key):
+        raise NotImplementedError
+
+    def _format_all(self):
+        for key in self.keys_to_format:
+            self.data[key] = self.format(key)
+        self.keys_to_format.clear()
+
+
+class LazyRow(LazyDict):
+    def format(self, key):
+        return self.formatter.format_column(self.pa_table.select([key]))[0]
+
+
+class LazyBatch(LazyDict):
+    def format(self, key):
+        return self.formatter.format_column(self.pa_table.select([key]))
+
+
+class Formatter(Generic[RowFormat, ColumnFormat, BatchFormat]):
+    """
+    A formatter is an object that extracts and formats data from pyarrow tables.
+    It defines the formatting for rows, columns and batches.
+    """
+
+    simple_arrow_extractor = SimpleArrowExtractor
+    python_arrow_extractor = PythonArrowExtractor
+    numpy_arrow_extractor = NumpyArrowExtractor
+    pandas_arrow_extractor = PandasArrowExtractor
+
+    def __init__(self, features: Optional[Features] = None):
+        self.features = features
+        self.python_features_decoder = PythonFeaturesDecoder(self.features)
+        self.pandas_features_decoder = PandasFeaturesDecoder(self.features)
+
+    def __call__(self, pa_table: pa.Table, query_type: str) -> Union[RowFormat, ColumnFormat, BatchFormat]:
+        if query_type == "row":
+            return self.format_row(pa_table)
+        elif query_type == "column":
+            return self.format_column(pa_table)
+        elif query_type == "batch":
+            return self.format_batch(pa_table)
+
+    def format_row(self, pa_table: pa.Table) -> RowFormat:
+        raise NotImplementedError
+
+    def format_column(self, pa_table: pa.Table) -> ColumnFormat:
+        raise NotImplementedError
+
+    def format_batch(self, pa_table: pa.Table) -> BatchFormat:
+        raise NotImplementedError
+
+
+class TensorFormatter(Formatter[RowFormat, ColumnFormat, BatchFormat]):
+    def recursive_tensorize(self, data_struct: dict):
+        raise NotImplementedError
+
+
+class ArrowFormatter(Formatter[pa.Table, pa.Array, pa.Table]):
+    def format_row(self, pa_table: pa.Table) -> pa.Table:
+        return self.simple_arrow_extractor().extract_row(pa_table)
+
+    def format_column(self, pa_table: pa.Table) -> pa.Array:
+        return self.simple_arrow_extractor().extract_column(pa_table)
+
+    def format_batch(self, pa_table: pa.Table) -> pa.Table:
+        return self.simple_arrow_extractor().extract_batch(pa_table)
+
+
+class PythonFormatter(Formatter[Mapping, list, Mapping]):
+    def __init__(self, features=None, lazy=False):
+        super().__init__(features)
+        self.lazy = lazy
+
+    def format_row(self, pa_table: pa.Table) -> Mapping:
+        if self.lazy:
+            return LazyRow(pa_table, self)
+        row = self.python_arrow_extractor().extract_row(pa_table)
+        row = self.python_features_decoder.decode_row(row)
+        return row
+
+    def format_column(self, pa_table: pa.Table) -> list:
+        column = self.python_arrow_extractor().extract_column(pa_table)
+        column = self.python_features_decoder.decode_column(column, pa_table.column_names[0])
+        return column
+
+    def format_batch(self, pa_table: pa.Table) -> Mapping:
+        if self.lazy:
+            return LazyBatch(pa_table, self)
+        batch = self.python_arrow_extractor().extract_batch(pa_table)
+        batch = self.python_features_decoder.decode_batch(batch)
+        return batch
+
+
+class PandasFormatter(Formatter[pd.DataFrame, pd.Series, pd.DataFrame]):
+    def format_row(self, pa_table: pa.Table) -> pd.DataFrame:
+        row = self.pandas_arrow_extractor().extract_row(pa_table)
+        row = self.pandas_features_decoder.decode_row(row)
+        return row
+
+    def format_column(self, pa_table: pa.Table) -> pd.Series:
+        column = self.pandas_arrow_extractor().extract_column(pa_table)
+        column = self.pandas_features_decoder.decode_column(column, pa_table.column_names[0])
+        return column
+
+    def format_batch(self, pa_table: pa.Table) -> pd.DataFrame:
+        row = self.pandas_arrow_extractor().extract_batch(pa_table)
+        row = self.pandas_features_decoder.decode_batch(row)
+        return row
+
+
+class CustomFormatter(Formatter[dict, ColumnFormat, dict]):
+    """
+    A user-defined custom formatter function defined by a ``transform``.
+    The transform must take as input a batch of data extracted for an arrow table using the python extractor,
+    and return a batch.
+    If the output batch is not a dict, then output_all_columns won't work.
+    If the ouput batch has several fields, then querying a single column won't work since we don't know which field
+    to return.
+    """
+
+    def __init__(self, transform: Callable[[dict], dict], features=None, **kwargs):
+        super().__init__(features=features)
+        self.transform = transform
+
+    def format_row(self, pa_table: pa.Table) -> dict:
+        formatted_batch = self.format_batch(pa_table)
+        try:
+            return _unnest(formatted_batch)
+        except Exception as exc:
+            raise TypeError(
+                f"Custom formatting function must return a dict of sequences to be able to pick a row, but got {formatted_batch}"
+            ) from exc
+
+    def format_column(self, pa_table: pa.Table) -> ColumnFormat:
+        formatted_batch = self.format_batch(pa_table)
+        if hasattr(formatted_batch, "keys"):
+            if len(formatted_batch.keys()) > 1:
+                raise TypeError(
+                    "Tried to query a column but the custom formatting function returns too many columns. "
+                    f"Only one column was expected but got columns {list(formatted_batch.keys())}."
+                )
+        else:
+            raise TypeError(
+                f"Custom formatting function must return a dict to be able to pick a row, but got {formatted_batch}"
+            )
+        try:
+            return formatted_batch[pa_table.column_names[0]]
+        except Exception as exc:
+            raise TypeError(
+                f"Custom formatting function must return a dict to be able to pick a row, but got {formatted_batch}"
+            ) from exc
+
+    def format_batch(self, pa_table: pa.Table) -> dict:
+        batch = self.python_arrow_extractor().extract_batch(pa_table)
+        batch = self.python_features_decoder.decode_batch(batch)
+        return self.transform(batch)
+
+
+def _check_valid_column_key(key: str, columns: List[str]) -> None:
+    if key not in columns:
+        raise KeyError(f"Column {key} not in the dataset. Current columns in the dataset: {columns}")
+
+
+def _check_valid_index_key(key: Union[int, slice, range, Iterable], size: int) -> None:
+    if isinstance(key, int):
+        if (key < 0 and key + size < 0) or (key >= size):
+            raise IndexError(f"Invalid key: {key} is out of bounds for size {size}")
+        return
+    elif isinstance(key, slice):
+        pass
+    elif isinstance(key, range):
+        if len(key) > 0:
+            _check_valid_index_key(max(key), size=size)
+            _check_valid_index_key(min(key), size=size)
+    elif isinstance(key, Iterable):
+        if len(key) > 0:
+            _check_valid_index_key(int(max(key)), size=size)
+            _check_valid_index_key(int(min(key)), size=size)
+    else:
+        _raise_bad_key_type(key)
+
+
+def key_to_query_type(key: Union[int, slice, range, str, Iterable]) -> str:
+    if isinstance(key, int):
+        return "row"
+    elif isinstance(key, str):
+        return "column"
+    elif isinstance(key, (slice, range, Iterable)):
+        return "batch"
+    _raise_bad_key_type(key)
+
+
+def query_table(
+    table: Table,
+    key: Union[int, slice, range, str, Iterable],
+    indices: Optional[Table] = None,
+) -> pa.Table:
+    """
+    Query a Table to extract the subtable that correspond to the given key.
+
+    Args:
+        table (``datasets.table.Table``): The input Table to query from
+        key (``Union[int, slice, range, str, Iterable]``): The key can be of different types:
+            - an integer i: the subtable containing only the i-th row
+            - a slice [i:j:k]: the subtable containing the rows that correspond to this slice
+            - a range(i, j, k): the subtable containing the rows that correspond to this range
+            - a string c: the subtable containing all the rows but only the column c
+            - an iterable l: the subtable that is the concatenation of all the i-th rows for all i in the iterable
+        indices (Optional ``datasets.table.Table``): If not None, it is used to re-map the given key to the table rows.
+            The indices table must contain one column named "indices" of type uint64.
+            This is used in case of shuffling or rows selection.
+
+
+    Returns:
+        ``pyarrow.Table``: the result of the query on the input table
+    """
+    # Check if key is valid
+    if not isinstance(key, (int, slice, range, str, Iterable)):
+        try:
+            key = operator.index(key)
+        except TypeError:
+            _raise_bad_key_type(key)
+    if isinstance(key, str):
+        _check_valid_column_key(key, table.column_names)
+    else:
+        size = indices.num_rows if indices is not None else table.num_rows
+        _check_valid_index_key(key, size)
+    # Query the main table
+    if indices is None:
+        pa_subtable = _query_table(table, key)
+    else:
+        pa_subtable = _query_table_with_indices_mapping(table, key, indices=indices)
+    return pa_subtable
+
+
+def format_table(
+    table: Table,
+    key: Union[int, slice, range, str, Iterable],
+    formatter: Formatter,
+    format_columns: Optional[list] = None,
+    output_all_columns=False,
+):
+    """
+    Format a Table depending on the key that was used and a Formatter object.
+
+    Args:
+        table (``datasets.table.Table``): The input Table to format
+        key (``Union[int, slice, range, str, Iterable]``): Depending on the key that was used, the formatter formats
+            the table as either a row, a column or a batch.
+        formatter (``datasets.formatting.formatting.Formatter``): Any subclass of a Formatter such as
+            PythonFormatter, NumpyFormatter, etc.
+        format_columns (:obj:`List[str]`, optional): if not None, it defines the columns that will be formatted using the
+            given formatter. Other columns are discarded (unless ``output_all_columns`` is True)
+        output_all_columns (:obj:`bool`, defaults to False). If True, the formatted output is completed using the columns
+            that are not in the ``format_columns`` list. For these columns, the PythonFormatter is used.
+
+
+    Returns:
+        A row, column or batch formatted object defined by the Formatter:
+        - the PythonFormatter returns a dictionary for a row or a batch, and a list for a column.
+        - the NumpyFormatter returns a dictionary for a row or a batch, and a np.array for a column.
+        - the PandasFormatter returns a pd.DataFrame for a row or a batch, and a pd.Series for a column.
+        - the TorchFormatter returns a dictionary for a row or a batch, and a torch.Tensor for a column.
+        - the TFFormatter returns a dictionary for a row or a batch, and a tf.Tensor for a column.
+    """
+    if isinstance(table, Table):
+        pa_table = table.table
+    else:
+        pa_table = table
+    query_type = key_to_query_type(key)
+    python_formatter = PythonFormatter(features=formatter.features)
+    if format_columns is None:
+        return formatter(pa_table, query_type=query_type)
+    elif query_type == "column":
+        if key in format_columns:
+            return formatter(pa_table, query_type)
+        else:
+            return python_formatter(pa_table, query_type=query_type)
+    else:
+        pa_table_to_format = pa_table.drop(col for col in pa_table.column_names if col not in format_columns)
+        formatted_output = formatter(pa_table_to_format, query_type=query_type)
+        if output_all_columns:
+            if isinstance(formatted_output, MutableMapping):
+                pa_table_with_remaining_columns = pa_table.drop(
+                    col for col in pa_table.column_names if col in format_columns
+                )
+                remaining_columns_dict = python_formatter(pa_table_with_remaining_columns, query_type=query_type)
+                formatted_output.update(remaining_columns_dict)
+            else:
+                raise TypeError(
+                    f"Custom formatting function must return a dict to work with output_all_columns=True, but got {formatted_output}"
+                )
+        return formatted_output