Add files using upload-large-folder tool

env-llmeval/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()

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

env-llmeval/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()

env-llmeval/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)

env-llmeval/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"

env-llmeval/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}")

env-llmeval/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.")

env-llmeval/lib/python3.10/site-packages/datasets/download/__init__.py

@@ -0,0 +1,10 @@
+__all__ = [
+    "DownloadConfig",
+    "DownloadManager",
+    "DownloadMode",
+    "StreamingDownloadManager",
+]
+
+from .download_config import DownloadConfig
+from .download_manager import DownloadManager, DownloadMode
+from .streaming_download_manager import StreamingDownloadManager

env-llmeval/lib/python3.10/site-packages/datasets/download/download_config.py

@@ -0,0 +1,102 @@
+import copy
+import warnings
+from dataclasses import InitVar, dataclass, field
+from pathlib import Path
+from typing import Any, Dict, Optional, Union
+
+from .. import config
+
+
+@dataclass
+class DownloadConfig:
+    """Configuration for our cached path manager.
+
+    Attributes:
+        cache_dir (`str` or `Path`, *optional*):
+            Specify a cache directory to save the file to (overwrite the
+            default cache dir).
+        force_download (`bool`, defaults to `False`):
+            If `True`, re-dowload the file even if it's already cached in
+            the cache dir.
+        resume_download (`bool`, defaults to `False`):
+            If `True`, resume the download if an incompletely received file is
+            found.
+        proxies (`dict`, *optional*):
+        user_agent (`str`, *optional*):
+            Optional string or dict that will be appended to the user-agent on remote
+            requests.
+        extract_compressed_file (`bool`, defaults to `False`):
+            If `True` and the path point to a zip or tar file,
+            extract the compressed file in a folder along the archive.
+        force_extract (`bool`, defaults to `False`):
+            If `True` when `extract_compressed_file` is `True` and the archive
+            was already extracted, re-extract the archive and override the folder where it was extracted.
+        delete_extracted (`bool`, defaults to `False`):
+            Whether to delete (or keep) the extracted files.
+        use_etag (`bool`, defaults to `True`):
+            Whether to use the ETag HTTP response header to validate the cached files.
+        num_proc (`int`, *optional*):
+            The number of processes to launch to download the files in parallel.
+        max_retries (`int`, default to `1`):
+            The number of times to retry an HTTP request if it fails.
+        token (`str` or `bool`, *optional*):
+            Optional string or boolean to use as Bearer token
+            for remote files on the Datasets Hub. If `True`, or not specified, will get token from `~/.huggingface`.
+        use_auth_token (`str` or `bool`, *optional*):
+            Optional string or boolean to use as Bearer token
+            for remote files on the Datasets Hub. If `True`, or not specified, will get token from `~/.huggingface`.
+
+            <Deprecated version="2.14.0">
+
+            `use_auth_token` was deprecated in favor of `token` in version 2.14.0 and will be removed in 3.0.0.
+
+            </Deprecated>
+
+        ignore_url_params (`bool`, defaults to `False`):
+            Whether to strip all query parameters and fragments from
+            the download URL before using it for caching the file.
+        storage_options (`dict`, *optional*):
+            Key/value pairs to be passed on to the dataset file-system backend, if any.
+        download_desc (`str`, *optional*):
+            A description to be displayed alongside with the progress bar while downloading the files.
+    """
+
+    cache_dir: Optional[Union[str, Path]] = None
+    force_download: bool = False
+    resume_download: bool = False
+    local_files_only: bool = False
+    proxies: Optional[Dict] = None
+    user_agent: Optional[str] = None
+    extract_compressed_file: bool = False
+    force_extract: bool = False
+    delete_extracted: bool = False
+    use_etag: bool = True
+    num_proc: Optional[int] = None
+    max_retries: int = 1
+    token: Optional[Union[str, bool]] = None
+    use_auth_token: InitVar[Optional[Union[str, bool]]] = "deprecated"
+    ignore_url_params: bool = False
+    storage_options: Dict[str, Any] = field(default_factory=dict)
+    download_desc: Optional[str] = None
+
+    def __post_init__(self, use_auth_token):
+        if use_auth_token != "deprecated":
+            warnings.warn(
+                "'use_auth_token' was deprecated in favor of 'token' in version 2.14.0 and will be removed in 3.0.0.\n"
+                f"You can remove this warning by passing 'token={use_auth_token}' instead.",
+                FutureWarning,
+            )
+            self.token = use_auth_token
+        if "hf" not in self.storage_options:
+            self.storage_options["hf"] = {"token": self.token, "endpoint": config.HF_ENDPOINT}
+
+    def copy(self) -> "DownloadConfig":
+        return self.__class__(**{k: copy.deepcopy(v) for k, v in self.__dict__.items()})
+
+    def __setattr__(self, name, value):
+        if name == "token" and getattr(self, "storage_options", None) is not None:
+            if "hf" not in self.storage_options:
+                self.storage_options["hf"] = {"token": value, "endpoint": config.HF_ENDPOINT}
+            elif getattr(self.storage_options["hf"], "token", None) is None:
+                self.storage_options["hf"]["token"] = value
+        super().__setattr__(name, value)

env-llmeval/lib/python3.10/site-packages/datasets/download/download_manager.py

@@ -0,0 +1,584 @@
+# Copyright 2020 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.
+
+# Lint as: python3
+"""Download manager interface."""
+
+import enum
+import io
+import os
+import posixpath
+import tarfile
+import warnings
+import zipfile
+from datetime import datetime
+from functools import partial
+from itertools import chain
+from typing import Callable, Dict, Generator, List, Optional, Tuple, Union
+
+from .. import config
+from ..utils import tqdm as hf_tqdm
+from ..utils.deprecation_utils import DeprecatedEnum, deprecated
+from ..utils.file_utils import (
+    cached_path,
+    get_from_cache,
+    hash_url_to_filename,
+    is_relative_path,
+    stack_multiprocessing_download_progress_bars,
+    url_or_path_join,
+)
+from ..utils.info_utils import get_size_checksum_dict
+from ..utils.logging import get_logger
+from ..utils.py_utils import NestedDataStructure, map_nested, size_str
+from ..utils.track import TrackedIterable, tracked_str
+from .download_config import DownloadConfig
+
+
+logger = get_logger(__name__)
+
+
+BASE_KNOWN_EXTENSIONS = [
+    "txt",
+    "csv",
+    "json",
+    "jsonl",
+    "tsv",
+    "conll",
+    "conllu",
+    "orig",
+    "parquet",
+    "pkl",
+    "pickle",
+    "rel",
+    "xml",
+]
+MAGIC_NUMBER_TO_COMPRESSION_PROTOCOL = {
+    bytes.fromhex("504B0304"): "zip",
+    bytes.fromhex("504B0506"): "zip",  # empty archive
+    bytes.fromhex("504B0708"): "zip",  # spanned archive
+    bytes.fromhex("425A68"): "bz2",
+    bytes.fromhex("1F8B"): "gzip",
+    bytes.fromhex("FD377A585A00"): "xz",
+    bytes.fromhex("04224D18"): "lz4",
+    bytes.fromhex("28B52FFD"): "zstd",
+}
+MAGIC_NUMBER_TO_UNSUPPORTED_COMPRESSION_PROTOCOL = {
+    b"Rar!": "rar",
+}
+MAGIC_NUMBER_MAX_LENGTH = max(
+    len(magic_number)
+    for magic_number in chain(MAGIC_NUMBER_TO_COMPRESSION_PROTOCOL, MAGIC_NUMBER_TO_UNSUPPORTED_COMPRESSION_PROTOCOL)
+)
+
+
+class DownloadMode(enum.Enum):
+    """`Enum` for how to treat pre-existing downloads and data.
+
+    The default mode is `REUSE_DATASET_IF_EXISTS`, which will reuse both
+    raw downloads and the prepared dataset if they exist.
+
+    The generations modes:
+
+    |                                     | Downloads | Dataset |
+    |-------------------------------------|-----------|---------|
+    | `REUSE_DATASET_IF_EXISTS` (default) | Reuse     | Reuse   |
+    | `REUSE_CACHE_IF_EXISTS`             | Reuse     | Fresh   |
+    | `FORCE_REDOWNLOAD`                  | Fresh     | Fresh   |
+
+    """
+
+    REUSE_DATASET_IF_EXISTS = "reuse_dataset_if_exists"
+    REUSE_CACHE_IF_EXISTS = "reuse_cache_if_exists"
+    FORCE_REDOWNLOAD = "force_redownload"
+
+
+class GenerateMode(DeprecatedEnum):
+    REUSE_DATASET_IF_EXISTS = "reuse_dataset_if_exists"
+    REUSE_CACHE_IF_EXISTS = "reuse_cache_if_exists"
+    FORCE_REDOWNLOAD = "force_redownload"
+
+    @property
+    def help_message(self):
+        return "Use 'DownloadMode' instead."
+
+
+def _get_path_extension(path: str) -> str:
+    # Get extension: train.json.gz -> gz
+    extension = path.split(".")[-1]
+    # Remove query params ("dl=1", "raw=true"): gz?dl=1 -> gz
+    # Remove shards infos (".txt_1", ".txt-00000-of-00100"): txt_1 -> txt
+    for symb in "?-_":
+        extension = extension.split(symb)[0]
+    return extension
+
+
+def _get_extraction_protocol_with_magic_number(f) -> Optional[str]:
+    """read the magic number from a file-like object and return the compression protocol"""
+    # Check if the file object is seekable even before reading the magic number (to avoid https://bugs.python.org/issue26440)
+    try:
+        f.seek(0)
+    except (AttributeError, io.UnsupportedOperation):
+        return None
+    magic_number = f.read(MAGIC_NUMBER_MAX_LENGTH)
+    f.seek(0)
+    for i in range(MAGIC_NUMBER_MAX_LENGTH):
+        compression = MAGIC_NUMBER_TO_COMPRESSION_PROTOCOL.get(magic_number[: MAGIC_NUMBER_MAX_LENGTH - i])
+        if compression is not None:
+            return compression
+        compression = MAGIC_NUMBER_TO_UNSUPPORTED_COMPRESSION_PROTOCOL.get(magic_number[: MAGIC_NUMBER_MAX_LENGTH - i])
+        if compression is not None:
+            raise NotImplementedError(f"Compression protocol '{compression}' not implemented.")
+
+
+def _get_extraction_protocol(path: str) -> Optional[str]:
+    path = str(path)
+    extension = _get_path_extension(path)
+    # TODO(mariosasko): The below check will be useful once we can preserve the original extension in the new cache layout (use the `filename` parameter of `hf_hub_download`)
+    if (
+        extension in BASE_KNOWN_EXTENSIONS
+        or extension in ["tgz", "tar"]
+        or path.endswith((".tar.gz", ".tar.bz2", ".tar.xz"))
+    ):
+        return None
+    with open(path, "rb") as f:
+        return _get_extraction_protocol_with_magic_number(f)
+
+
+class _IterableFromGenerator(TrackedIterable):
+    """Utility class to create an iterable from a generator function, in order to reset the generator when needed."""
+
+    def __init__(self, generator: Callable, *args, **kwargs):
+        super().__init__()
+        self.generator = generator
+        self.args = args
+        self.kwargs = kwargs
+
+    def __iter__(self):
+        for x in self.generator(*self.args, **self.kwargs):
+            self.last_item = x
+            yield x
+        self.last_item = None
+
+
+class ArchiveIterable(_IterableFromGenerator):
+    """An iterable of (path, fileobj) from a TAR archive, used by `iter_archive`"""
+
+    @staticmethod
+    def _iter_tar(f):
+        stream = tarfile.open(fileobj=f, mode="r|*")
+        for tarinfo in stream:
+            file_path = tarinfo.name
+            if not tarinfo.isreg():
+                continue
+            if file_path is None:
+                continue
+            if os.path.basename(file_path).startswith((".", "__")):
+                # skipping hidden files
+                continue
+            file_obj = stream.extractfile(tarinfo)
+            yield file_path, file_obj
+            stream.members = []
+        del stream
+
+    @staticmethod
+    def _iter_zip(f):
+        zipf = zipfile.ZipFile(f)
+        for member in zipf.infolist():
+            file_path = member.filename
+            if member.is_dir():
+                continue
+            if file_path is None:
+                continue
+            if os.path.basename(file_path).startswith((".", "__")):
+                # skipping hidden files
+                continue
+            file_obj = zipf.open(member)
+            yield file_path, file_obj
+
+    @classmethod
+    def _iter_from_fileobj(cls, f) -> Generator[Tuple, None, None]:
+        compression = _get_extraction_protocol_with_magic_number(f)
+        if compression == "zip":
+            yield from cls._iter_zip(f)
+        else:
+            yield from cls._iter_tar(f)
+
+    @classmethod
+    def _iter_from_path(cls, urlpath: str) -> Generator[Tuple, None, None]:
+        compression = _get_extraction_protocol(urlpath)
+        with open(urlpath, "rb") as f:
+            if compression == "zip":
+                yield from cls._iter_zip(f)
+            else:
+                yield from cls._iter_tar(f)
+
+    @classmethod
+    def from_buf(cls, fileobj) -> "ArchiveIterable":
+        return cls(cls._iter_from_fileobj, fileobj)
+
+    @classmethod
+    def from_path(cls, urlpath_or_buf) -> "ArchiveIterable":
+        return cls(cls._iter_from_path, urlpath_or_buf)
+
+
+class FilesIterable(_IterableFromGenerator):
+    """An iterable of paths from a list of directories or files"""
+
+    @classmethod
+    def _iter_from_paths(cls, urlpaths: Union[str, List[str]]) -> Generator[str, None, None]:
+        if not isinstance(urlpaths, list):
+            urlpaths = [urlpaths]
+        for urlpath in urlpaths:
+            if os.path.isfile(urlpath):
+                yield urlpath
+            else:
+                for dirpath, dirnames, filenames in os.walk(urlpath):
+                    # in-place modification to prune the search
+                    dirnames[:] = sorted([dirname for dirname in dirnames if not dirname.startswith((".", "__"))])
+                    if os.path.basename(dirpath).startswith((".", "__")):
+                        # skipping hidden directories
+                        continue
+                    for filename in sorted(filenames):
+                        if filename.startswith((".", "__")):
+                            # skipping hidden files
+                            continue
+                        yield os.path.join(dirpath, filename)
+
+    @classmethod
+    def from_paths(cls, urlpaths) -> "FilesIterable":
+        return cls(cls._iter_from_paths, urlpaths)
+
+
+class DownloadManager:
+    is_streaming = False
+
+    def __init__(
+        self,
+        dataset_name: Optional[str] = None,
+        data_dir: Optional[str] = None,
+        download_config: Optional[DownloadConfig] = None,
+        base_path: Optional[str] = None,
+        record_checksums=True,
+    ):
+        """Download manager constructor.
+
+        Args:
+            data_dir:
+                can be used to specify a manual directory to get the files from.
+            dataset_name (`str`):
+                name of dataset this instance will be used for. If
+                provided, downloads will contain which datasets they were used for.
+            download_config (`DownloadConfig`):
+                to specify the cache directory and other
+                download options
+            base_path (`str`):
+                base path that is used when relative paths are used to
+                download files. This can be a remote url.
+            record_checksums (`bool`, defaults to `True`):
+                Whether to record the checksums of the downloaded files. If None, the value is inferred from the builder.
+        """
+        self._dataset_name = dataset_name
+        self._data_dir = data_dir
+        self._base_path = base_path or os.path.abspath(".")
+        # To record what is being used: {url: {num_bytes: int, checksum: str}}
+        self._recorded_sizes_checksums: Dict[str, Dict[str, Optional[Union[int, str]]]] = {}
+        self.record_checksums = record_checksums
+        self.download_config = download_config or DownloadConfig()
+        self.downloaded_paths = {}
+        self.extracted_paths = {}
+
+    @property
+    def manual_dir(self):
+        return self._data_dir
+
+    @property
+    def downloaded_size(self):
+        """Returns the total size of downloaded files."""
+        return sum(checksums_dict["num_bytes"] for checksums_dict in self._recorded_sizes_checksums.values())
+
+    @staticmethod
+    def ship_files_with_pipeline(downloaded_path_or_paths, pipeline):
+        """Ship the files using Beam FileSystems to the pipeline temp dir.
+
+        Args:
+            downloaded_path_or_paths (`str` or `list[str]` or `dict[str, str]`):
+                Nested structure containing the
+                downloaded path(s).
+            pipeline ([`utils.beam_utils.BeamPipeline`]):
+                Apache Beam Pipeline.
+
+        Returns:
+            `str` or `list[str]` or `dict[str, str]`
+        """
+        from ..utils.beam_utils import upload_local_to_remote
+
+        remote_dir = pipeline._options.get_all_options().get("temp_location")
+        if remote_dir is None:
+            raise ValueError("You need to specify 'temp_location' in PipelineOptions to upload files")
+
+        def upload(local_file_path):
+            remote_file_path = posixpath.join(
+                remote_dir, config.DOWNLOADED_DATASETS_DIR, os.path.basename(local_file_path)
+            )
+            logger.info(
+                f"Uploading {local_file_path} ({size_str(os.path.getsize(local_file_path))}) to {remote_file_path}."
+            )
+            upload_local_to_remote(local_file_path, remote_file_path)
+            return remote_file_path
+
+        uploaded_path_or_paths = map_nested(
+            lambda local_file_path: upload(local_file_path),
+            downloaded_path_or_paths,
+        )
+        return uploaded_path_or_paths
+
+    def _record_sizes_checksums(self, url_or_urls: NestedDataStructure, downloaded_path_or_paths: NestedDataStructure):
+        """Record size/checksum of downloaded files."""
+        delay = 5
+        for url, path in hf_tqdm(
+            list(zip(url_or_urls.flatten(), downloaded_path_or_paths.flatten())),
+            delay=delay,
+            desc="Computing checksums",
+        ):
+            # call str to support PathLike objects
+            self._recorded_sizes_checksums[str(url)] = get_size_checksum_dict(
+                path, record_checksum=self.record_checksums
+            )
+
+    @deprecated("Use `.download`/`.download_and_extract` with `fsspec` URLs instead.")
+    def download_custom(self, url_or_urls, custom_download):
+        """
+        Download given urls(s) by calling `custom_download`.
+
+        Args:
+            url_or_urls (`str` or `list` or `dict`):
+                URL or `list` or `dict` of URLs to download and extract. Each URL is a `str`.
+            custom_download (`Callable[src_url, dst_path]`):
+                The source URL and destination path. For example
+                `tf.io.gfile.copy`, that lets you download from  Google storage.
+
+        Returns:
+            downloaded_path(s): `str`, The downloaded paths matching the given input
+                `url_or_urls`.
+
+        Example:
+
+        ```py
+        >>> downloaded_files = dl_manager.download_custom('s3://my-bucket/data.zip', custom_download_for_my_private_bucket)
+        ```
+        """
+        cache_dir = self.download_config.cache_dir or config.DOWNLOADED_DATASETS_PATH
+        max_retries = self.download_config.max_retries
+
+        def url_to_downloaded_path(url):
+            return os.path.join(cache_dir, hash_url_to_filename(url))
+
+        downloaded_path_or_paths = map_nested(url_to_downloaded_path, url_or_urls)
+        url_or_urls = NestedDataStructure(url_or_urls)
+        downloaded_path_or_paths = NestedDataStructure(downloaded_path_or_paths)
+        for url, path in zip(url_or_urls.flatten(), downloaded_path_or_paths.flatten()):
+            try:
+                get_from_cache(
+                    url, cache_dir=cache_dir, local_files_only=True, use_etag=False, max_retries=max_retries
+                )
+                cached = True
+            except FileNotFoundError:
+                cached = False
+            if not cached or self.download_config.force_download:
+                custom_download(url, path)
+                get_from_cache(
+                    url, cache_dir=cache_dir, local_files_only=True, use_etag=False, max_retries=max_retries
+                )
+        self._record_sizes_checksums(url_or_urls, downloaded_path_or_paths)
+        return downloaded_path_or_paths.data
+
+    def download(self, url_or_urls):
+        """Download given URL(s).
+
+        By default, only one process is used for download. Pass customized `download_config.num_proc` to change this behavior.
+
+        Args:
+            url_or_urls (`str` or `list` or `dict`):
+                URL or `list` or `dict` of URLs to download. Each URL is a `str`.
+
+        Returns:
+            `str` or `list` or `dict`:
+                The downloaded paths matching the given input `url_or_urls`.
+
+        Example:
+
+        ```py
+        >>> downloaded_files = dl_manager.download('https://storage.googleapis.com/seldon-datasets/sentence_polarity_v1/rt-polaritydata.tar.gz')
+        ```
+        """
+        download_config = self.download_config.copy()
+        download_config.extract_compressed_file = False
+        if download_config.download_desc is None:
+            download_config.download_desc = "Downloading data"
+
+        download_func = partial(self._download, download_config=download_config)
+
+        start_time = datetime.now()
+        with stack_multiprocessing_download_progress_bars():
+            downloaded_path_or_paths = map_nested(
+                download_func,
+                url_or_urls,
+                map_tuple=True,
+                num_proc=download_config.num_proc,
+                desc="Downloading data files",
+            )
+        duration = datetime.now() - start_time
+        logger.info(f"Downloading took {duration.total_seconds() // 60} min")
+        url_or_urls = NestedDataStructure(url_or_urls)
+        downloaded_path_or_paths = NestedDataStructure(downloaded_path_or_paths)
+        self.downloaded_paths.update(dict(zip(url_or_urls.flatten(), downloaded_path_or_paths.flatten())))
+
+        start_time = datetime.now()
+        self._record_sizes_checksums(url_or_urls, downloaded_path_or_paths)
+        duration = datetime.now() - start_time
+        logger.info(f"Checksum Computation took {duration.total_seconds() // 60} min")
+
+        return downloaded_path_or_paths.data
+
+    def _download(self, url_or_filename: str, download_config: DownloadConfig) -> str:
+        url_or_filename = str(url_or_filename)
+        if is_relative_path(url_or_filename):
+            # append the relative path to the base_path
+            url_or_filename = url_or_path_join(self._base_path, url_or_filename)
+        out = cached_path(url_or_filename, download_config=download_config)
+        out = tracked_str(out)
+        out.set_origin(url_or_filename)
+        return out
+
+    def iter_archive(self, path_or_buf: Union[str, io.BufferedReader]):
+        """Iterate over files within an archive.
+
+        Args:
+            path_or_buf (`str` or `io.BufferedReader`):
+                Archive path or archive binary file object.
+
+        Yields:
+            `tuple[str, io.BufferedReader]`:
+                2-tuple (path_within_archive, file_object).
+                File object is opened in binary mode.
+
+        Example:
+
+        ```py
+        >>> archive = dl_manager.download('https://storage.googleapis.com/seldon-datasets/sentence_polarity_v1/rt-polaritydata.tar.gz')
+        >>> files = dl_manager.iter_archive(archive)
+        ```
+        """
+
+        if hasattr(path_or_buf, "read"):
+            return ArchiveIterable.from_buf(path_or_buf)
+        else:
+            return ArchiveIterable.from_path(path_or_buf)
+
+    def iter_files(self, paths: Union[str, List[str]]):
+        """Iterate over file paths.
+
+        Args:
+            paths (`str` or `list` of `str`):
+                Root paths.
+
+        Yields:
+            `str`: File path.
+
+        Example:
+
+        ```py
+        >>> files = dl_manager.download_and_extract('https://huggingface.co/datasets/beans/resolve/main/data/train.zip')
+        >>> files = dl_manager.iter_files(files)
+        ```
+        """
+        return FilesIterable.from_paths(paths)
+
+    def extract(self, path_or_paths, num_proc="deprecated"):
+        """Extract given path(s).
+
+        Args:
+            path_or_paths (path or `list` or `dict`):
+                Path of file to extract. Each path is a `str`.
+            num_proc (`int`):
+                Use multi-processing if `num_proc` > 1 and the length of
+                `path_or_paths` is larger than `num_proc`.
+
+                <Deprecated version="2.6.2">
+
+                Pass `DownloadConfig(num_proc=<num_proc>)` to the initializer instead.
+
+                </Deprecated>
+
+        Returns:
+            extracted_path(s): `str`, The extracted paths matching the given input
+            path_or_paths.
+
+        Example:
+
+        ```py
+        >>> downloaded_files = dl_manager.download('https://storage.googleapis.com/seldon-datasets/sentence_polarity_v1/rt-polaritydata.tar.gz')
+        >>> extracted_files = dl_manager.extract(downloaded_files)
+        ```
+        """
+        if num_proc != "deprecated":
+            warnings.warn(
+                "'num_proc' was deprecated in version 2.6.2 and will be removed in 3.0.0. Pass `DownloadConfig(num_proc=<num_proc>)` to the initializer instead.",
+                FutureWarning,
+            )
+        download_config = self.download_config.copy()
+        download_config.extract_compressed_file = True
+        extract_func = partial(self._download, download_config=download_config)
+        extracted_paths = map_nested(
+            extract_func,
+            path_or_paths,
+            num_proc=download_config.num_proc,
+            desc="Extracting data files",
+        )
+        path_or_paths = NestedDataStructure(path_or_paths)
+        extracted_paths = NestedDataStructure(extracted_paths)
+        self.extracted_paths.update(dict(zip(path_or_paths.flatten(), extracted_paths.flatten())))
+        return extracted_paths.data
+
+    def download_and_extract(self, url_or_urls):
+        """Download and extract given `url_or_urls`.
+
+        Is roughly equivalent to:
+
+        ```
+        extracted_paths = dl_manager.extract(dl_manager.download(url_or_urls))
+        ```
+
+        Args:
+            url_or_urls (`str` or `list` or `dict`):
+                URL or `list` or `dict` of URLs to download and extract. Each URL is a `str`.
+
+        Returns:
+            extracted_path(s): `str`, extracted paths of given URL(s).
+        """
+        return self.extract(self.download(url_or_urls))
+
+    def get_recorded_sizes_checksums(self):
+        return self._recorded_sizes_checksums.copy()
+
+    def delete_extracted_files(self):
+        paths_to_delete = set(self.extracted_paths.values()) - set(self.downloaded_paths.values())
+        for key, path in list(self.extracted_paths.items()):
+            if path in paths_to_delete and os.path.isfile(path):
+                os.remove(path)
+                del self.extracted_paths[key]
+
+    def manage_extracted_files(self):
+        if self.download_config.delete_extracted:
+            self.delete_extracted_files()

env-llmeval/lib/python3.10/site-packages/datasets/download/mock_download_manager.py

@@ -0,0 +1,244 @@
+# Copyright 2020 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.
+
+# Lint as: python3
+"""Mock download manager interface."""
+
+import os
+import re
+import urllib.parse
+from pathlib import Path
+from typing import Callable, List, Optional, Union
+from zipfile import ZipFile
+
+from ..utils.file_utils import cached_path, hf_github_url
+from ..utils.logging import get_logger
+from ..utils.version import Version
+
+
+logger = get_logger(__name__)
+
+
+class MockDownloadManager:
+    dummy_file_name = "dummy_data"
+    datasets_scripts_dir = "datasets"
+    is_streaming = False
+
+    def __init__(
+        self,
+        dataset_name: str,
+        config: str,
+        version: Union[Version, str],
+        cache_dir: Optional[str] = None,
+        use_local_dummy_data: bool = False,
+        load_existing_dummy_data: bool = True,
+        download_callbacks: Optional[List[Callable]] = None,
+    ):
+        self.downloaded_size = 0
+        self.dataset_name = dataset_name
+        self.cache_dir = cache_dir
+        self.use_local_dummy_data = use_local_dummy_data
+        self.config = config
+        # download_callbacks take a single url as input
+        self.download_callbacks: List[Callable] = download_callbacks or []
+        # if False, it doesn't load existing files and it returns the paths of the dummy files relative
+        # to the dummy_data zip file root
+        self.load_existing_dummy_data = load_existing_dummy_data
+
+        # TODO(PVP, QL) might need to make this more general
+        self.version_name = str(version)
+        # to be downloaded
+        self._dummy_file = None
+        self._bucket_url = None
+
+    @property
+    def dummy_file(self):
+        if self._dummy_file is None:
+            self._dummy_file = self.download_dummy_data()
+        return self._dummy_file
+
+    @property
+    def dummy_data_folder(self):
+        if self.config is not None:
+            # structure is dummy / config_name / version_name
+            return os.path.join("dummy", self.config.name, self.version_name)
+        # structure is dummy / version_name
+        return os.path.join("dummy", self.version_name)
+
+    @property
+    def dummy_zip_file(self):
+        return os.path.join(self.dummy_data_folder, "dummy_data.zip")
+
+    def download_dummy_data(self):
+        path_to_dummy_data_dir = (
+            self.local_path_to_dummy_data if self.use_local_dummy_data is True else self.github_path_to_dummy_data
+        )
+
+        local_path = cached_path(
+            path_to_dummy_data_dir, cache_dir=self.cache_dir, extract_compressed_file=True, force_extract=True
+        )
+
+        return os.path.join(local_path, self.dummy_file_name)
+
+    @property
+    def local_path_to_dummy_data(self):
+        return os.path.join(self.datasets_scripts_dir, self.dataset_name, self.dummy_zip_file)
+
+    @property
+    def github_path_to_dummy_data(self):
+        if self._bucket_url is None:
+            self._bucket_url = hf_github_url(self.dataset_name, self.dummy_zip_file.replace(os.sep, "/"))
+        return self._bucket_url
+
+    @property
+    def manual_dir(self):
+        # return full path if its a dir
+        if os.path.isdir(self.dummy_file):
+            return self.dummy_file
+        # else cut off path to file -> example `xsum`.
+        return "/".join(self.dummy_file.replace(os.sep, "/").split("/")[:-1])
+
+    # this function has to be in the manager under this name so that testing works
+    def download_and_extract(self, data_url, *args):
+        if self.load_existing_dummy_data:
+            # dummy data is downloaded and tested
+            dummy_file = self.dummy_file
+        else:
+            # dummy data cannot be downloaded and only the path to dummy file is returned
+            dummy_file = self.dummy_file_name
+
+        # special case when data_url is a dict
+        if isinstance(data_url, dict):
+            return self.create_dummy_data_dict(dummy_file, data_url)
+        elif isinstance(data_url, (list, tuple)):
+            return self.create_dummy_data_list(dummy_file, data_url)
+        else:
+            return self.create_dummy_data_single(dummy_file, data_url)
+
+    # this function has to be in the manager under this name so that testing works
+    def download(self, data_url, *args):
+        return self.download_and_extract(data_url)
+
+    # this function has to be in the manager under this name so that testing works
+    def download_custom(self, data_url, custom_download):
+        return self.download_and_extract(data_url)
+
+    # this function has to be in the manager under this name so that testing works
+    def extract(self, path, *args, **kwargs):
+        return path
+
+    # this function has to be in the manager under this name so that testing works
+    def get_recorded_sizes_checksums(self):
+        return {}
+
+    def create_dummy_data_dict(self, path_to_dummy_data, data_url):
+        dummy_data_dict = {}
+        for key, single_urls in data_url.items():
+            for download_callback in self.download_callbacks:
+                if isinstance(single_urls, list):
+                    for single_url in single_urls:
+                        download_callback(single_url)
+                else:
+                    single_url = single_urls
+                    download_callback(single_url)
+            # we force the name of each key to be the last file / folder name of the url path
+            # if the url has arguments, we need to encode them with urllib.parse.quote_plus
+            if isinstance(single_urls, list):
+                value = [os.path.join(path_to_dummy_data, urllib.parse.quote_plus(Path(x).name)) for x in single_urls]
+            else:
+                single_url = single_urls
+                value = os.path.join(path_to_dummy_data, urllib.parse.quote_plus(Path(single_url).name))
+            dummy_data_dict[key] = value
+
+        # make sure that values are unique
+        if all(isinstance(i, str) for i in dummy_data_dict.values()) and len(set(dummy_data_dict.values())) < len(
+            dummy_data_dict.values()
+        ):
+            # append key to value to make its name unique
+            dummy_data_dict = {key: value + key for key, value in dummy_data_dict.items()}
+
+        return dummy_data_dict
+
+    def create_dummy_data_list(self, path_to_dummy_data, data_url):
+        dummy_data_list = []
+        # trick: if there are many shards named like `data.txt-000001-of-00300`, only use the first one
+        is_tf_records = all(bool(re.findall("[0-9]{3,}-of-[0-9]{3,}", url)) for url in data_url)
+        is_pubmed_records = all(
+            url.startswith("https://ftp.ncbi.nlm.nih.gov/pubmed/baseline/pubmed") for url in data_url
+        )
+        if data_url and (is_tf_records or is_pubmed_records):
+            data_url = [data_url[0]] * len(data_url)
+        for single_url in data_url:
+            for download_callback in self.download_callbacks:
+                download_callback(single_url)
+            # we force the name of each key to be the last file / folder name of the url path
+            # if the url has arguments, we need to encode them with urllib.parse.quote_plus
+            value = os.path.join(path_to_dummy_data, urllib.parse.quote_plus(single_url.split("/")[-1]))
+            dummy_data_list.append(value)
+        return dummy_data_list
+
+    def create_dummy_data_single(self, path_to_dummy_data, data_url):
+        for download_callback in self.download_callbacks:
+            download_callback(data_url)
+        # we force the name of each key to be the last file / folder name of the url path
+        # if the url has arguments, we need to encode them with urllib.parse.quote_plus
+        value = os.path.join(path_to_dummy_data, urllib.parse.quote_plus(data_url.split("/")[-1]))
+        if os.path.exists(value) or not self.load_existing_dummy_data:
+            return value
+        else:
+            # Backward compatibility, maybe deprecate at one point.
+            # For many datasets with single url calls to dl_manager.download_and_extract,
+            # the dummy_data.zip file is actually the zipped downloaded file
+            # while now we expected the dummy_data.zip file to be a directory containing
+            # the downloaded file.
+            return path_to_dummy_data
+
+    def delete_extracted_files(self):
+        pass
+
+    def manage_extracted_files(self):
+        pass
+
+    def iter_archive(self, path):
+        def _iter_archive_members(path):
+            # this preserves the order of the members inside the ZIP archive
+            dummy_parent_path = Path(self.dummy_file).parent
+            relative_path = path.relative_to(dummy_parent_path)
+            with ZipFile(self.local_path_to_dummy_data) as zip_file:
+                members = zip_file.namelist()
+            for member in members:
+                if member.startswith(relative_path.as_posix()):
+                    yield dummy_parent_path.joinpath(member)
+
+        path = Path(path)
+        file_paths = _iter_archive_members(path) if self.use_local_dummy_data else path.rglob("*")
+        for file_path in file_paths:
+            if file_path.is_file() and not file_path.name.startswith((".", "__")):
+                yield file_path.relative_to(path).as_posix(), file_path.open("rb")
+
+    def iter_files(self, paths):
+        if not isinstance(paths, list):
+            paths = [paths]
+        for path in paths:
+            if os.path.isfile(path):
+                yield path
+            else:
+                for dirpath, dirnames, filenames in os.walk(path):
+                    if os.path.basename(dirpath).startswith((".", "__")):
+                        continue
+                    dirnames.sort()
+                    for filename in sorted(filenames):
+                        if filename.startswith((".", "__")):
+                            continue
+                        yield os.path.join(dirpath, filename)

env-llmeval/lib/python3.10/site-packages/datasets/download/streaming_download_manager.py

@@ -0,0 +1,1133 @@
+import glob
+import io
+import os
+import posixpath
+import re
+import tarfile
+import time
+import xml.dom.minidom
+import zipfile
+from asyncio import TimeoutError
+from io import BytesIO
+from itertools import chain
+from pathlib import Path, PurePosixPath
+from typing import Any, Callable, Dict, Generator, Iterable, List, Optional, Tuple, Union
+from xml.etree import ElementTree as ET
+
+import fsspec
+from aiohttp.client_exceptions import ClientError
+from huggingface_hub.utils import EntryNotFoundError
+from packaging import version
+
+from .. import config
+from ..filesystems import COMPRESSION_FILESYSTEMS
+from ..utils.file_utils import (
+    get_authentication_headers_for_url,
+    get_datasets_user_agent,
+    http_head,
+    is_local_path,
+    is_relative_path,
+    url_or_path_join,
+)
+from ..utils.logging import get_logger
+from ..utils.py_utils import map_nested
+from .download_config import DownloadConfig
+
+
+logger = get_logger(__name__)
+
+BASE_KNOWN_EXTENSIONS = [
+    "txt",
+    "csv",
+    "json",
+    "jsonl",
+    "tsv",
+    "conll",
+    "conllu",
+    "orig",
+    "parquet",
+    "pkl",
+    "pickle",
+    "rel",
+    "xml",
+]
+COMPRESSION_EXTENSION_TO_PROTOCOL = {
+    # single file compression
+    **{fs_class.extension.lstrip("."): fs_class.protocol for fs_class in COMPRESSION_FILESYSTEMS},
+    # archive compression
+    "zip": "zip",
+}
+SINGLE_FILE_COMPRESSION_PROTOCOLS = {fs_class.protocol for fs_class in COMPRESSION_FILESYSTEMS}
+SINGLE_SLASH_AFTER_PROTOCOL_PATTERN = re.compile(r"(?<!:):/")
+
+
+MAGIC_NUMBER_TO_COMPRESSION_PROTOCOL = {
+    bytes.fromhex("504B0304"): "zip",
+    bytes.fromhex("504B0506"): "zip",  # empty archive
+    bytes.fromhex("504B0708"): "zip",  # spanned archive
+    bytes.fromhex("425A68"): "bz2",
+    bytes.fromhex("1F8B"): "gzip",
+    bytes.fromhex("FD377A585A00"): "xz",
+    bytes.fromhex("04224D18"): "lz4",
+    bytes.fromhex("28B52FFD"): "zstd",
+}
+MAGIC_NUMBER_TO_UNSUPPORTED_COMPRESSION_PROTOCOL = {
+    b"Rar!": "rar",
+}
+MAGIC_NUMBER_MAX_LENGTH = max(
+    len(magic_number)
+    for magic_number in chain(MAGIC_NUMBER_TO_COMPRESSION_PROTOCOL, MAGIC_NUMBER_TO_UNSUPPORTED_COMPRESSION_PROTOCOL)
+)
+
+
+class NonStreamableDatasetError(Exception):
+    pass
+
+
+def xjoin(a, *p):
+    """
+    This function extends os.path.join to support the "::" hop separator. It supports both paths and urls.
+
+    A shorthand, particularly useful where you have multiple hops, is to “chain” the URLs with the special separator "::".
+    This is used to access files inside a zip file over http for example.
+
+    Let's say you have a zip file at https://host.com/archive.zip, and you want to access the file inside the zip file at /folder1/file.txt.
+    Then you can just chain the url this way:
+
+        zip://folder1/file.txt::https://host.com/archive.zip
+
+    The xjoin function allows you to apply the join on the first path of the chain.
+
+    Example::
+
+        >>> xjoin("zip://folder1::https://host.com/archive.zip", "file.txt")
+        zip://folder1/file.txt::https://host.com/archive.zip
+    """
+    a, *b = str(a).split("::")
+    if is_local_path(a):
+        return os.path.join(a, *p)
+    else:
+        a = posixpath.join(a, *p)
+        return "::".join([a] + b)
+
+
+def xdirname(a):
+    """
+    This function extends os.path.dirname to support the "::" hop separator. It supports both paths and urls.
+
+    A shorthand, particularly useful where you have multiple hops, is to “chain” the URLs with the special separator "::".
+    This is used to access files inside a zip file over http for example.
+
+    Let's say you have a zip file at https://host.com/archive.zip, and you want to access the file inside the zip file at /folder1/file.txt.
+    Then you can just chain the url this way:
+
+        zip://folder1/file.txt::https://host.com/archive.zip
+
+    The xdirname function allows you to apply the dirname on the first path of the chain.
+
+    Example::
+
+        >>> xdirname("zip://folder1/file.txt::https://host.com/archive.zip")
+        zip://folder1::https://host.com/archive.zip
+    """
+    a, *b = str(a).split("::")
+    if is_local_path(a):
+        a = os.path.dirname(Path(a).as_posix())
+    else:
+        a = posixpath.dirname(a)
+    # if we end up at the root of the protocol, we get for example a = 'http:'
+    # so we have to fix it by adding the '//' that was removed:
+    if a.endswith(":"):
+        a += "//"
+    return "::".join([a] + b)
+
+
+def xexists(urlpath: str, download_config: Optional[DownloadConfig] = None):
+    """Extend `os.path.exists` function to support both local and remote files.
+
+    Args:
+        urlpath (`str`): URL path.
+        download_config : mainly use token or storage_options to support different platforms and auth types.
+
+    Returns:
+        `bool`
+    """
+
+    main_hop, *rest_hops = _as_str(urlpath).split("::")
+    if is_local_path(main_hop):
+        return os.path.exists(main_hop)
+    else:
+        urlpath, storage_options = _prepare_path_and_storage_options(urlpath, download_config=download_config)
+        main_hop, *rest_hops = urlpath.split("::")
+        fs, *_ = fsspec.get_fs_token_paths(urlpath, storage_options=storage_options)
+        return fs.exists(main_hop)
+
+
+def xbasename(a):
+    """
+    This function extends os.path.basename to support the "::" hop separator. It supports both paths and urls.
+
+    A shorthand, particularly useful where you have multiple hops, is to “chain” the URLs with the special separator "::".
+    This is used to access files inside a zip file over http for example.
+
+    Let's say you have a zip file at https://host.com/archive.zip, and you want to access the file inside the zip file at /folder1/file.txt.
+    Then you can just chain the url this way:
+
+        zip://folder1/file.txt::https://host.com/archive.zip
+
+    The xbasename function allows you to apply the basename on the first path of the chain.
+
+    Example::
+
+        >>> xbasename("zip://folder1/file.txt::https://host.com/archive.zip")
+        file.txt
+    """
+    a, *b = str(a).split("::")
+    if is_local_path(a):
+        return os.path.basename(Path(a).as_posix())
+    else:
+        return posixpath.basename(a)
+
+
+def xsplit(a):
+    """
+    This function extends os.path.split to support the "::" hop separator. It supports both paths and urls.
+
+    A shorthand, particularly useful where you have multiple hops, is to “chain” the URLs with the special separator "::".
+    This is used to access files inside a zip file over http for example.
+
+    Let's say you have a zip file at https://host.com/archive.zip, and you want to access the file inside the zip file at /folder1/file.txt.
+    Then you can just chain the url this way:
+
+        zip://folder1/file.txt::https://host.com/archive.zip
+
+    The xsplit function allows you to apply the xsplit on the first path of the chain.
+
+    Example::
+
+        >>> xsplit("zip://folder1/file.txt::https://host.com/archive.zip")
+        ('zip://folder1::https://host.com/archive.zip', 'file.txt')
+    """
+    a, *b = str(a).split("::")
+    if is_local_path(a):
+        return os.path.split(Path(a).as_posix())
+    else:
+        a, tail = posixpath.split(a)
+        return "::".join([a + "//" if a.endswith(":") else a] + b), tail
+
+
+def xsplitext(a):
+    """
+    This function extends os.path.splitext to support the "::" hop separator. It supports both paths and urls.
+
+    A shorthand, particularly useful where you have multiple hops, is to “chain” the URLs with the special separator "::".
+    This is used to access files inside a zip file over http for example.
+
+    Let's say you have a zip file at https://host.com/archive.zip, and you want to access the file inside the zip file at /folder1/file.txt.
+    Then you can just chain the url this way:
+
+        zip://folder1/file.txt::https://host.com/archive.zip
+
+    The xsplitext function allows you to apply the splitext on the first path of the chain.
+
+    Example::
+
+        >>> xsplitext("zip://folder1/file.txt::https://host.com/archive.zip")
+        ('zip://folder1/file::https://host.com/archive.zip', '.txt')
+    """
+    a, *b = str(a).split("::")
+    if is_local_path(a):
+        return os.path.splitext(Path(a).as_posix())
+    else:
+        a, ext = posixpath.splitext(a)
+        return "::".join([a] + b), ext
+
+
+def xisfile(path, download_config: Optional[DownloadConfig] = None) -> bool:
+    """Extend `os.path.isfile` function to support remote files.
+
+    Args:
+        path (`str`): URL path.
+        download_config : mainly use token or storage_options to support different platforms and auth types.
+
+    Returns:
+        `bool`
+    """
+    main_hop, *rest_hops = str(path).split("::")
+    if is_local_path(main_hop):
+        return os.path.isfile(path)
+    else:
+        path, storage_options = _prepare_path_and_storage_options(path, download_config=download_config)
+        main_hop, *rest_hops = path.split("::")
+        fs, *_ = fsspec.get_fs_token_paths(path, storage_options=storage_options)
+        return fs.isfile(main_hop)
+
+
+def xgetsize(path, download_config: Optional[DownloadConfig] = None) -> int:
+    """Extend `os.path.getsize` function to support remote files.
+
+    Args:
+        path (`str`): URL path.
+        download_config : mainly use token or storage_options to support different platforms and auth types.
+
+    Returns:
+        `int`: optional
+    """
+    main_hop, *rest_hops = str(path).split("::")
+    if is_local_path(main_hop):
+        return os.path.getsize(path)
+    else:
+        path, storage_options = _prepare_path_and_storage_options(path, download_config=download_config)
+        main_hop, *rest_hops = path.split("::")
+        fs, *_ = fsspec.get_fs_token_paths(path, storage_options=storage_options)
+        try:
+            size = fs.size(main_hop)
+        except EntryNotFoundError:
+            raise FileNotFoundError(f"No such file: {path}")
+        if size is None:
+            # use xopen instead of fs.open to make data fetching more robust
+            with xopen(path, download_config=download_config) as f:
+                size = len(f.read())
+        return size
+
+
+def xisdir(path, download_config: Optional[DownloadConfig] = None) -> bool:
+    """Extend `os.path.isdir` function to support remote files.
+
+    Args:
+        path (`str`): URL path.
+        download_config : mainly use token or storage_options to support different platforms and auth types.
+
+    Returns:
+        `bool`
+    """
+    main_hop, *rest_hops = str(path).split("::")
+    if is_local_path(main_hop):
+        return os.path.isdir(path)
+    else:
+        path, storage_options = _prepare_path_and_storage_options(path, download_config=download_config)
+        main_hop, *rest_hops = path.split("::")
+        fs, *_ = fsspec.get_fs_token_paths(path, storage_options=storage_options)
+        inner_path = main_hop.split("://")[-1]
+        if not inner_path.strip("/"):
+            return True
+        return fs.isdir(inner_path)
+
+
+def xrelpath(path, start=None):
+    """Extend `os.path.relpath` function to support remote files.
+
+    Args:
+        path (`str`): URL path.
+        start (`str`): Start URL directory path.
+
+    Returns:
+        `str`
+    """
+    main_hop, *rest_hops = str(path).split("::")
+    if is_local_path(main_hop):
+        return os.path.relpath(main_hop, start=start) if start else os.path.relpath(main_hop)
+    else:
+        return posixpath.relpath(main_hop, start=str(start).split("::")[0]) if start else os.path.relpath(main_hop)
+
+
+def _add_retries_to_file_obj_read_method(file_obj):
+    read = file_obj.read
+    max_retries = config.STREAMING_READ_MAX_RETRIES
+
+    def read_with_retries(*args, **kwargs):
+        disconnect_err = None
+        for retry in range(1, max_retries + 1):
+            try:
+                out = read(*args, **kwargs)
+                break
+            except (ClientError, TimeoutError) as err:
+                disconnect_err = err
+                logger.warning(
+                    f"Got disconnected from remote data host. Retrying in {config.STREAMING_READ_RETRY_INTERVAL}sec [{retry}/{max_retries}]"
+                )
+                time.sleep(config.STREAMING_READ_RETRY_INTERVAL)
+        else:
+            raise ConnectionError("Server Disconnected") from disconnect_err
+        return out
+
+    file_obj.read = read_with_retries
+
+
+def _get_path_extension(path: str) -> str:
+    # Get extension: https://foo.bar/train.json.gz -> gz
+    extension = path.split(".")[-1]
+    # Remove query params ("dl=1", "raw=true"): gz?dl=1 -> gz
+    # Remove shards infos (".txt_1", ".txt-00000-of-00100"): txt_1 -> txt
+    for symb in "?-_":
+        extension = extension.split(symb)[0]
+    return extension
+
+
+def _get_extraction_protocol_with_magic_number(f) -> Optional[str]:
+    """read the magic number from a file-like object and return the compression protocol"""
+    # Check if the file object is seekable even before reading the magic number (to avoid https://bugs.python.org/issue26440)
+    try:
+        f.seek(0)
+    except (AttributeError, io.UnsupportedOperation):
+        return None
+    magic_number = f.read(MAGIC_NUMBER_MAX_LENGTH)
+    f.seek(0)
+    for i in range(MAGIC_NUMBER_MAX_LENGTH):
+        compression = MAGIC_NUMBER_TO_COMPRESSION_PROTOCOL.get(magic_number[: MAGIC_NUMBER_MAX_LENGTH - i])
+        if compression is not None:
+            return compression
+        compression = MAGIC_NUMBER_TO_UNSUPPORTED_COMPRESSION_PROTOCOL.get(magic_number[: MAGIC_NUMBER_MAX_LENGTH - i])
+        if compression is not None:
+            raise NotImplementedError(f"Compression protocol '{compression}' not implemented.")
+
+
+def _get_extraction_protocol(urlpath: str, download_config: Optional[DownloadConfig] = None) -> Optional[str]:
+    # get inner file: zip://train-00000.json.gz::https://foo.bar/data.zip -> zip://train-00000.json.gz
+    urlpath = str(urlpath)
+    path = urlpath.split("::")[0]
+    extension = _get_path_extension(path)
+    if (
+        extension in BASE_KNOWN_EXTENSIONS
+        or extension in ["tgz", "tar"]
+        or path.endswith((".tar.gz", ".tar.bz2", ".tar.xz"))
+    ):
+        return None
+    elif extension in COMPRESSION_EXTENSION_TO_PROTOCOL:
+        return COMPRESSION_EXTENSION_TO_PROTOCOL[extension]
+    urlpath, storage_options = _prepare_path_and_storage_options(urlpath, download_config=download_config)
+    try:
+        with fsspec.open(urlpath, **(storage_options or {})) as f:
+            return _get_extraction_protocol_with_magic_number(f)
+    except FileNotFoundError:
+        if urlpath.startswith(config.HF_ENDPOINT):
+            raise FileNotFoundError(
+                urlpath + "\nIf the repo is private or gated, make sure to log in with `huggingface-cli login`."
+            ) from None
+        else:
+            raise
+
+
+def _prepare_path_and_storage_options(
+    urlpath: str, download_config: Optional[DownloadConfig] = None
+) -> Tuple[str, Dict[str, Dict[str, Any]]]:
+    prepared_urlpath = []
+    prepared_storage_options = {}
+    for hop in urlpath.split("::"):
+        hop, storage_options = _prepare_single_hop_path_and_storage_options(hop, download_config=download_config)
+        prepared_urlpath.append(hop)
+        prepared_storage_options.update(storage_options)
+    return "::".join(prepared_urlpath), storage_options
+
+
+def _prepare_single_hop_path_and_storage_options(
+    urlpath: str, download_config: Optional[DownloadConfig] = None
+) -> Tuple[str, Dict[str, Dict[str, Any]]]:
+    """
+    Prepare the URL and the kwargs that must be passed to the HttpFileSystem or to requests.get/head
+
+    In particular it resolves google drive URLs
+    It also adds the authentication headers for the Hugging Face Hub, for both https:// and hf:// paths.
+
+    Storage options are formatted in the form {protocol: storage_options_for_protocol}
+    """
+    token = None if download_config is None else download_config.token
+    if urlpath.startswith(config.HF_ENDPOINT) and "/resolve/" in urlpath:
+        urlpath = "hf://" + urlpath[len(config.HF_ENDPOINT) + 1 :].replace("/resolve/", "@", 1)
+    protocol = urlpath.split("://")[0] if "://" in urlpath else "file"
+    if download_config is not None and protocol in download_config.storage_options:
+        storage_options = download_config.storage_options[protocol]
+    elif download_config is not None and protocol not in download_config.storage_options:
+        storage_options = {
+            option_name: option_value
+            for option_name, option_value in download_config.storage_options.items()
+            if option_name not in fsspec.available_protocols()
+        }
+    else:
+        storage_options = {}
+    if storage_options:
+        storage_options = {protocol: storage_options}
+    if protocol in ["http", "https"]:
+        storage_options[protocol] = {
+            "headers": {
+                **get_authentication_headers_for_url(urlpath, token=token),
+                "user-agent": get_datasets_user_agent(),
+            },
+            "client_kwargs": {"trust_env": True},  # Enable reading proxy env variables.
+            **(storage_options.get(protocol, {})),
+        }
+        if "drive.google.com" in urlpath:
+            response = http_head(urlpath)
+            cookies = None
+            for k, v in response.cookies.items():
+                if k.startswith("download_warning"):
+                    urlpath += "&confirm=" + v
+                    cookies = response.cookies
+                    storage_options[protocol] = {"cookies": cookies, **storage_options.get(protocol, {})}
+        # Fix Google Drive URL to avoid Virus scan warning
+        if "drive.google.com" in urlpath and "confirm=" not in urlpath:
+            urlpath += "&confirm=t"
+        if urlpath.startswith("https://raw.githubusercontent.com/"):
+            # Workaround for served data with gzip content-encoding: https://github.com/fsspec/filesystem_spec/issues/389
+            storage_options[protocol]["headers"]["Accept-Encoding"] = "identity"
+    elif protocol == "hf":
+        storage_options[protocol] = {
+            "token": token,
+            "endpoint": config.HF_ENDPOINT,
+            **storage_options.get(protocol, {}),
+        }
+        # streaming with block_size=0 is only implemented in 0.21 (see https://github.com/huggingface/huggingface_hub/pull/1967)
+        if config.HF_HUB_VERSION < version.parse("0.21.0"):
+            storage_options[protocol]["block_size"] = "default"
+    return urlpath, storage_options
+
+
+def xopen(file: str, mode="r", *args, download_config: Optional[DownloadConfig] = None, **kwargs):
+    """Extend `open` function to support remote files using `fsspec`.
+
+    It also has a retry mechanism in case connection fails.
+    The `args` and `kwargs` are passed to `fsspec.open`, except `token` which is used for queries to private repos on huggingface.co
+
+    Args:
+        file (`str`): Path name of the file to be opened.
+        mode (`str`, *optional*, default "r"): Mode in which the file is opened.
+        *args: Arguments to be passed to `fsspec.open`.
+        download_config : mainly use token or storage_options to support different platforms and auth types.
+        **kwargs: Keyword arguments to be passed to `fsspec.open`.
+
+    Returns:
+        file object
+    """
+    # This works as well for `xopen(str(Path(...)))`
+    file_str = _as_str(file)
+    main_hop, *rest_hops = file_str.split("::")
+    if is_local_path(main_hop):
+        # ignore fsspec-specific kwargs
+        kwargs.pop("block_size", None)
+        return open(main_hop, mode, *args, **kwargs)
+    # add headers and cookies for authentication on the HF Hub and for Google Drive
+    file, storage_options = _prepare_path_and_storage_options(file_str, download_config=download_config)
+    kwargs = {**kwargs, **(storage_options or {})}
+    try:
+        file_obj = fsspec.open(file, mode=mode, *args, **kwargs).open()
+    except ValueError as e:
+        if str(e) == "Cannot seek streaming HTTP file":
+            raise NonStreamableDatasetError(
+                "Streaming is not possible for this dataset because data host server doesn't support HTTP range "
+                "requests. You can still load this dataset in non-streaming mode by passing `streaming=False` (default)"
+            ) from e
+        else:
+            raise
+    except FileNotFoundError:
+        if file.startswith(config.HF_ENDPOINT):
+            raise FileNotFoundError(
+                file + "\nIf the repo is private or gated, make sure to log in with `huggingface-cli login`."
+            ) from None
+        else:
+            raise
+    _add_retries_to_file_obj_read_method(file_obj)
+    return file_obj
+
+
+def xlistdir(path: str, download_config: Optional[DownloadConfig] = None) -> List[str]:
+    """Extend `os.listdir` function to support remote files.
+
+    Args:
+        path (`str`): URL path.
+        download_config : mainly use token or storage_options to support different platforms and auth types.
+
+    Returns:
+        `list` of `str`
+    """
+    main_hop, *rest_hops = _as_str(path).split("::")
+    if is_local_path(main_hop):
+        return os.listdir(path)
+    else:
+        # globbing inside a zip in a private repo requires authentication
+        path, storage_options = _prepare_path_and_storage_options(path, download_config=download_config)
+        main_hop, *rest_hops = path.split("::")
+        fs, *_ = fsspec.get_fs_token_paths(path, storage_options=storage_options)
+        inner_path = main_hop.split("://")[-1]
+        if inner_path.strip("/") and not fs.isdir(inner_path):
+            raise FileNotFoundError(f"Directory doesn't exist: {path}")
+        paths = fs.listdir(inner_path, detail=False)
+        return [os.path.basename(path.rstrip("/")) for path in paths]
+
+
+def xglob(urlpath, *, recursive=False, download_config: Optional[DownloadConfig] = None):
+    """Extend `glob.glob` function to support remote files.
+
+    Args:
+        urlpath (`str`): URL path with shell-style wildcard patterns.
+        recursive (`bool`, default `False`): Whether to match the "**" pattern recursively to zero or more
+            directories or subdirectories.
+        download_config : mainly use token or storage_options to support different platforms and auth types.
+
+    Returns:
+        `list` of `str`
+    """
+    main_hop, *rest_hops = _as_str(urlpath).split("::")
+    if is_local_path(main_hop):
+        return glob.glob(main_hop, recursive=recursive)
+    else:
+        # globbing inside a zip in a private repo requires authentication
+        urlpath, storage_options = _prepare_path_and_storage_options(urlpath, download_config=download_config)
+        main_hop, *rest_hops = urlpath.split("::")
+        fs, *_ = fsspec.get_fs_token_paths(urlpath, storage_options=storage_options)
+        # - If there's no "*" in the pattern, get_fs_token_paths() doesn't do any pattern matching
+        #   so to be able to glob patterns like "[0-9]", we have to call `fs.glob`.
+        # - Also "*" in get_fs_token_paths() only matches files: we have to call `fs.glob` to match directories.
+        # - If there is "**" in the pattern, `fs.glob` must be called anyway.
+        inner_path = main_hop.split("://")[1]
+        globbed_paths = fs.glob(inner_path)
+        protocol = fs.protocol if isinstance(fs.protocol, str) else fs.protocol[-1]
+        return ["::".join([f"{protocol}://{globbed_path}"] + rest_hops) for globbed_path in globbed_paths]
+
+
+def xwalk(urlpath, download_config: Optional[DownloadConfig] = None, **kwargs):
+    """Extend `os.walk` function to support remote files.
+
+    Args:
+        urlpath (`str`): URL root path.
+        download_config : mainly use token or storage_options to support different platforms and auth types.
+        **kwargs: Additional keyword arguments forwarded to the underlying filesystem.
+
+
+    Yields:
+        `tuple`: 3-tuple (dirpath, dirnames, filenames).
+    """
+    main_hop, *rest_hops = _as_str(urlpath).split("::")
+    if is_local_path(main_hop):
+        yield from os.walk(main_hop, **kwargs)
+    else:
+        # walking inside a zip in a private repo requires authentication
+        urlpath, storage_options = _prepare_path_and_storage_options(urlpath, download_config=download_config)
+        main_hop, *rest_hops = urlpath.split("::")
+        fs, *_ = fsspec.get_fs_token_paths(urlpath, storage_options=storage_options)
+        inner_path = main_hop.split("://")[-1]
+        if inner_path.strip("/") and not fs.isdir(inner_path):
+            return []
+        protocol = fs.protocol if isinstance(fs.protocol, str) else fs.protocol[-1]
+        for dirpath, dirnames, filenames in fs.walk(inner_path, **kwargs):
+            yield "::".join([f"{protocol}://{dirpath}"] + rest_hops), dirnames, filenames
+
+
+class xPath(type(Path())):
+    """Extension of `pathlib.Path` to support both local paths and remote URLs."""
+
+    def __str__(self):
+        path_str = super().__str__()
+        main_hop, *rest_hops = path_str.split("::")
+        if is_local_path(main_hop):
+            return main_hop
+        path_as_posix = path_str.replace("\\", "/")
+        path_as_posix = SINGLE_SLASH_AFTER_PROTOCOL_PATTERN.sub("://", path_as_posix)
+        path_as_posix += "//" if path_as_posix.endswith(":") else ""  # Add slashes to root of the protocol
+        return path_as_posix
+
+    def exists(self, download_config: Optional[DownloadConfig] = None):
+        """Extend `pathlib.Path.exists` method to support both local and remote files.
+
+        Args:
+            download_config : mainly use token or storage_options to support different platforms and auth types.
+
+        Returns:
+            `bool`
+        """
+        return xexists(str(self), download_config=download_config)
+
+    def glob(self, pattern, download_config: Optional[DownloadConfig] = None):
+        """Glob function for argument of type :obj:`~pathlib.Path` that supports both local paths end remote URLs.
+
+        Args:
+            pattern (`str`): Pattern that resulting paths must match.
+            download_config : mainly use token or storage_options to support different platforms and auth types.
+
+        Yields:
+            [`xPath`]
+        """
+        posix_path = self.as_posix()
+        main_hop, *rest_hops = posix_path.split("::")
+        if is_local_path(main_hop):
+            yield from Path(main_hop).glob(pattern)
+        else:
+            # globbing inside a zip in a private repo requires authentication
+            if rest_hops:
+                urlpath = rest_hops[0]
+                urlpath, storage_options = _prepare_path_and_storage_options(urlpath, download_config=download_config)
+                storage_options = {urlpath.split("://")[0]: storage_options}
+                posix_path = "::".join([main_hop, urlpath, *rest_hops[1:]])
+            else:
+                storage_options = None
+            fs, *_ = fsspec.get_fs_token_paths(xjoin(posix_path, pattern), storage_options=storage_options)
+            # - If there's no "*" in the pattern, get_fs_token_paths() doesn't do any pattern matching
+            #   so to be able to glob patterns like "[0-9]", we have to call `fs.glob`.
+            # - Also "*" in get_fs_token_paths() only matches files: we have to call `fs.glob` to match directories.
+            # - If there is "**" in the pattern, `fs.glob` must be called anyway.
+            globbed_paths = fs.glob(xjoin(main_hop, pattern))
+            for globbed_path in globbed_paths:
+                yield type(self)("::".join([f"{fs.protocol}://{globbed_path}"] + rest_hops))
+
+    def rglob(self, pattern, **kwargs):
+        """Rglob function for argument of type :obj:`~pathlib.Path` that supports both local paths end remote URLs.
+
+        Args:
+            pattern (`str`): Pattern that resulting paths must match.
+
+        Yields:
+            [`xPath`]
+        """
+        return self.glob("**/" + pattern, **kwargs)
+
+    @property
+    def parent(self) -> "xPath":
+        """Name function for argument of type :obj:`~pathlib.Path` that supports both local paths end remote URLs.
+
+        Returns:
+            [`xPath`]
+        """
+        return type(self)(xdirname(self.as_posix()))
+
+    @property
+    def name(self) -> str:
+        """Name function for argument of type :obj:`~pathlib.Path` that supports both local paths end remote URLs.
+
+        Returns:
+            `str`
+        """
+        return PurePosixPath(self.as_posix().split("::")[0]).name
+
+    @property
+    def stem(self) -> str:
+        """Stem function for argument of type :obj:`~pathlib.Path` that supports both local paths end remote URLs.
+
+        Returns:
+            `str`
+        """
+        return PurePosixPath(self.as_posix().split("::")[0]).stem
+
+    @property
+    def suffix(self) -> str:
+        """Suffix function for argument of type :obj:`~pathlib.Path` that supports both local paths end remote URLs.
+
+        Returns:
+            `str`
+        """
+        return PurePosixPath(self.as_posix().split("::")[0]).suffix
+
+    def open(self, *args, **kwargs):
+        """Extend :func:`xopen` to support argument of type :obj:`~pathlib.Path`.
+
+        Args:
+            **args: Arguments passed to :func:`fsspec.open`.
+            **kwargs: Keyword arguments passed to :func:`fsspec.open`.
+
+        Returns:
+            `io.FileIO`: File-like object.
+        """
+        return xopen(str(self), *args, **kwargs)
+
+    def joinpath(self, *p: Tuple[str, ...]) -> "xPath":
+        """Extend :func:`xjoin` to support argument of type :obj:`~pathlib.Path`.
+
+        Args:
+            *p (`tuple` of `str`): Other path components.
+
+        Returns:
+            [`xPath`]
+        """
+        return type(self)(xjoin(self.as_posix(), *p))
+
+    def __truediv__(self, p: str) -> "xPath":
+        return self.joinpath(p)
+
+    def with_suffix(self, suffix):
+        main_hop, *rest_hops = str(self).split("::")
+        if is_local_path(main_hop):
+            return type(self)(str(super().with_suffix(suffix)))
+        return type(self)("::".join([type(self)(PurePosixPath(main_hop).with_suffix(suffix)).as_posix()] + rest_hops))
+
+
+def _as_str(path: Union[str, Path, xPath]):
+    return str(path) if isinstance(path, xPath) else str(xPath(str(path)))
+
+
+def xgzip_open(filepath_or_buffer, *args, download_config: Optional[DownloadConfig] = None, **kwargs):
+    import gzip
+
+    if hasattr(filepath_or_buffer, "read"):
+        return gzip.open(filepath_or_buffer, *args, **kwargs)
+    else:
+        filepath_or_buffer = str(filepath_or_buffer)
+        return gzip.open(xopen(filepath_or_buffer, "rb", download_config=download_config), *args, **kwargs)
+
+
+def xnumpy_load(filepath_or_buffer, *args, download_config: Optional[DownloadConfig] = None, **kwargs):
+    import numpy as np
+
+    if hasattr(filepath_or_buffer, "read"):
+        return np.load(filepath_or_buffer, *args, **kwargs)
+    else:
+        filepath_or_buffer = str(filepath_or_buffer)
+        return np.load(xopen(filepath_or_buffer, "rb", download_config=download_config), *args, **kwargs)
+
+
+def xpandas_read_csv(filepath_or_buffer, download_config: Optional[DownloadConfig] = None, **kwargs):
+    import pandas as pd
+
+    if hasattr(filepath_or_buffer, "read"):
+        return pd.read_csv(filepath_or_buffer, **kwargs)
+    else:
+        filepath_or_buffer = str(filepath_or_buffer)
+        if kwargs.get("compression", "infer") == "infer":
+            kwargs["compression"] = _get_extraction_protocol(filepath_or_buffer, download_config=download_config)
+        return pd.read_csv(xopen(filepath_or_buffer, "rb", download_config=download_config), **kwargs)
+
+
+def xpandas_read_excel(filepath_or_buffer, download_config: Optional[DownloadConfig] = None, **kwargs):
+    import pandas as pd
+
+    if hasattr(filepath_or_buffer, "read"):
+        try:
+            return pd.read_excel(filepath_or_buffer, **kwargs)
+        except ValueError:  # Cannot seek streaming HTTP file
+            return pd.read_excel(BytesIO(filepath_or_buffer.read()), **kwargs)
+    else:
+        filepath_or_buffer = str(filepath_or_buffer)
+        try:
+            return pd.read_excel(xopen(filepath_or_buffer, "rb", download_config=download_config), **kwargs)
+        except ValueError:  # Cannot seek streaming HTTP file
+            return pd.read_excel(
+                BytesIO(xopen(filepath_or_buffer, "rb", download_config=download_config).read()), **kwargs
+            )
+
+
+def xpyarrow_parquet_read_table(filepath_or_buffer, download_config: Optional[DownloadConfig] = None, **kwargs):
+    import pyarrow.parquet as pq
+
+    if hasattr(filepath_or_buffer, "read"):
+        return pq.read_table(filepath_or_buffer, **kwargs)
+    else:
+        filepath_or_buffer = str(filepath_or_buffer)
+        return pq.read_table(xopen(filepath_or_buffer, mode="rb", download_config=download_config), **kwargs)
+
+
+def xsio_loadmat(filepath_or_buffer, download_config: Optional[DownloadConfig] = None, **kwargs):
+    import scipy.io as sio
+
+    if hasattr(filepath_or_buffer, "read"):
+        return sio.loadmat(filepath_or_buffer, **kwargs)
+    else:
+        return sio.loadmat(xopen(filepath_or_buffer, "rb", download_config=download_config), **kwargs)
+
+
+def xet_parse(source, parser=None, download_config: Optional[DownloadConfig] = None):
+    """Extend `xml.etree.ElementTree.parse` function to support remote files.
+
+    Args:
+        source: File path or file object.
+        parser (`XMLParser`, *optional*, default `XMLParser`): Parser instance.
+        download_config : mainly use token or storage_options to support different platforms and auth types.
+
+    Returns:
+        `xml.etree.ElementTree.Element`: Root element of the given source document.
+    """
+    if hasattr(source, "read"):
+        return ET.parse(source, parser=parser)
+    else:
+        with xopen(source, "rb", download_config=download_config) as f:
+            return ET.parse(f, parser=parser)
+
+
+def xxml_dom_minidom_parse(filename_or_file, download_config: Optional[DownloadConfig] = None, **kwargs):
+    """Extend `xml.dom.minidom.parse` function to support remote files.
+
+    Args:
+        filename_or_file (`str` or file): File path or file object.
+        download_config : mainly use token or storage_options to support different platforms and auth types.
+        **kwargs (optional): Additional keyword arguments passed to `xml.dom.minidom.parse`.
+
+    Returns:
+        :obj:`xml.dom.minidom.Document`: Parsed document.
+    """
+    if hasattr(filename_or_file, "read"):
+        return xml.dom.minidom.parse(filename_or_file, **kwargs)
+    else:
+        with xopen(filename_or_file, "rb", download_config=download_config) as f:
+            return xml.dom.minidom.parse(f, **kwargs)
+
+
+class _IterableFromGenerator(Iterable):
+    """Utility class to create an iterable from a generator function, in order to reset the generator when needed."""
+
+    def __init__(self, generator: Callable, *args, **kwargs):
+        self.generator = generator
+        self.args = args
+        self.kwargs = kwargs
+
+    def __iter__(self):
+        yield from self.generator(*self.args, **self.kwargs)
+
+
+class ArchiveIterable(_IterableFromGenerator):
+    """An iterable of (path, fileobj) from a TAR archive, used by `iter_archive`"""
+
+    @staticmethod
+    def _iter_tar(f):
+        stream = tarfile.open(fileobj=f, mode="r|*")
+        for tarinfo in stream:
+            file_path = tarinfo.name
+            if not tarinfo.isreg():
+                continue
+            if file_path is None:
+                continue
+            if os.path.basename(file_path).startswith((".", "__")):
+                # skipping hidden files
+                continue
+            file_obj = stream.extractfile(tarinfo)
+            yield file_path, file_obj
+            stream.members = []
+        del stream
+
+    @staticmethod
+    def _iter_zip(f):
+        zipf = zipfile.ZipFile(f)
+        for member in zipf.infolist():
+            file_path = member.filename
+            if member.is_dir():
+                continue
+            if file_path is None:
+                continue
+            if os.path.basename(file_path).startswith((".", "__")):
+                # skipping hidden files
+                continue
+            file_obj = zipf.open(member)
+            yield file_path, file_obj
+
+    @classmethod
+    def _iter_from_fileobj(cls, f) -> Generator[Tuple, None, None]:
+        compression = _get_extraction_protocol_with_magic_number(f)
+        if compression == "zip":
+            yield from cls._iter_zip(f)
+        else:
+            yield from cls._iter_tar(f)
+
+    @classmethod
+    def _iter_from_urlpath(
+        cls, urlpath: str, download_config: Optional[DownloadConfig] = None
+    ) -> Generator[Tuple, None, None]:
+        compression = _get_extraction_protocol(urlpath, download_config=download_config)
+        # Set block_size=0 to get faster streaming
+        # (e.g. for hf:// and https:// it uses streaming Requests file-like instances)
+        with xopen(urlpath, "rb", download_config=download_config, block_size=0) as f:
+            if compression == "zip":
+                yield from cls._iter_zip(f)
+            else:
+                yield from cls._iter_tar(f)
+
+    @classmethod
+    def from_buf(cls, fileobj) -> "ArchiveIterable":
+        return cls(cls._iter_from_fileobj, fileobj)
+
+    @classmethod
+    def from_urlpath(cls, urlpath_or_buf, download_config: Optional[DownloadConfig] = None) -> "ArchiveIterable":
+        return cls(cls._iter_from_urlpath, urlpath_or_buf, download_config)
+
+
+class FilesIterable(_IterableFromGenerator):
+    """An iterable of paths from a list of directories or files"""
+
+    @classmethod
+    def _iter_from_urlpaths(
+        cls, urlpaths: Union[str, List[str]], download_config: Optional[DownloadConfig] = None
+    ) -> Generator[str, None, None]:
+        if not isinstance(urlpaths, list):
+            urlpaths = [urlpaths]
+        for urlpath in urlpaths:
+            if xisfile(urlpath, download_config=download_config):
+                yield urlpath
+            elif xisdir(urlpath, download_config=download_config):
+                for dirpath, dirnames, filenames in xwalk(urlpath, download_config=download_config):
+                    # in-place modification to prune the search
+                    dirnames[:] = sorted([dirname for dirname in dirnames if not dirname.startswith((".", "__"))])
+                    if xbasename(dirpath).startswith((".", "__")):
+                        # skipping hidden directories
+                        continue
+                    for filename in sorted(filenames):
+                        if filename.startswith((".", "__")):
+                            # skipping hidden files
+                            continue
+                        yield xjoin(dirpath, filename)
+            else:
+                raise FileNotFoundError(urlpath)
+
+    @classmethod
+    def from_urlpaths(cls, urlpaths, download_config: Optional[DownloadConfig] = None) -> "FilesIterable":
+        return cls(cls._iter_from_urlpaths, urlpaths, download_config)
+
+
+class StreamingDownloadManager:
+    """
+    Download manager that uses the "::" separator to navigate through (possibly remote) compressed archives.
+    Contrary to the regular `DownloadManager`, the `download` and `extract` methods don't actually download nor extract
+    data, but they rather return the path or url that could be opened using the `xopen` function which extends the
+    built-in `open` function to stream data from remote files.
+    """
+
+    is_streaming = True
+
+    def __init__(
+        self,
+        dataset_name: Optional[str] = None,
+        data_dir: Optional[str] = None,
+        download_config: Optional[DownloadConfig] = None,
+        base_path: Optional[str] = None,
+    ):
+        self._dataset_name = dataset_name
+        self._data_dir = data_dir
+        self._base_path = base_path or os.path.abspath(".")
+        self.download_config = download_config or DownloadConfig()
+
+    @property
+    def manual_dir(self):
+        return self._data_dir
+
+    def download(self, url_or_urls):
+        """Normalize URL(s) of files to stream data from.
+        This is the lazy version of `DownloadManager.download` for streaming.
+
+        Args:
+            url_or_urls (`str` or `list` or `dict`):
+                URL(s) of files to stream data from. Each url is a `str`.
+
+        Returns:
+            url(s): (`str` or `list` or `dict`), URL(s) to stream data from matching the given input url_or_urls.
+
+        Example:
+
+        ```py
+        >>> downloaded_files = dl_manager.download('https://storage.googleapis.com/seldon-datasets/sentence_polarity_v1/rt-polaritydata.tar.gz')
+        ```
+        """
+        url_or_urls = map_nested(self._download, url_or_urls, map_tuple=True)
+        return url_or_urls
+
+    def _download(self, urlpath: str) -> str:
+        urlpath = str(urlpath)
+        if is_relative_path(urlpath):
+            # append the relative path to the base_path
+            urlpath = url_or_path_join(self._base_path, urlpath)
+        return urlpath
+
+    def extract(self, url_or_urls):
+        """Add extraction protocol for given url(s) for streaming.
+
+        This is the lazy version of `DownloadManager.extract` for streaming.
+
+        Args:
+            url_or_urls (`str` or `list` or `dict`):
+                URL(s) of files to stream data from. Each url is a `str`.
+
+        Returns:
+            url(s): (`str` or `list` or `dict`), URL(s) to stream data from matching the given input `url_or_urls`.
+
+        Example:
+
+        ```py
+        >>> downloaded_files = dl_manager.download('https://storage.googleapis.com/seldon-datasets/sentence_polarity_v1/rt-polaritydata.tar.gz')
+        >>> extracted_files = dl_manager.extract(downloaded_files)
+        ```
+        """
+        urlpaths = map_nested(self._extract, url_or_urls, map_tuple=True)
+        return urlpaths
+
+    def _extract(self, urlpath: str) -> str:
+        urlpath = str(urlpath)
+        protocol = _get_extraction_protocol(urlpath, download_config=self.download_config)
+        # get inner file: zip://train-00000.json.gz::https://foo.bar/data.zip -> zip://train-00000.json.gz
+        path = urlpath.split("::")[0]
+        extension = _get_path_extension(path)
+        if extension in ["tgz", "tar"] or path.endswith((".tar.gz", ".tar.bz2", ".tar.xz")):
+            raise NotImplementedError(
+                f"Extraction protocol for TAR archives like '{urlpath}' is not implemented in streaming mode. "
+                f"Please use `dl_manager.iter_archive` instead.\n\n"
+                f"Example usage:\n\n"
+                f"\turl = dl_manager.download(url)\n"
+                f"\ttar_archive_iterator = dl_manager.iter_archive(url)\n\n"
+                f"\tfor filename, file in tar_archive_iterator:\n"
+                f"\t\t..."
+            )
+        if protocol is None:
+            # no extraction
+            return urlpath
+        elif protocol in SINGLE_FILE_COMPRESSION_PROTOCOLS:
+            # there is one single file which is the uncompressed file
+            inner_file = os.path.basename(urlpath.split("::")[0])
+            inner_file = inner_file[: inner_file.rindex(".")] if "." in inner_file else inner_file
+            return f"{protocol}://{inner_file}::{urlpath}"
+        else:
+            return f"{protocol}://::{urlpath}"
+
+    def download_and_extract(self, url_or_urls):
+        """Prepare given `url_or_urls` for streaming (add extraction protocol).
+
+        This is the lazy version of `DownloadManager.download_and_extract` for streaming.
+
+        Is equivalent to:
+
+        ```
+        urls = dl_manager.extract(dl_manager.download(url_or_urls))
+        ```
+
+        Args:
+            url_or_urls (`str` or `list` or `dict`):
+                URL(s) to stream from data from. Each url is a `str`.
+
+        Returns:
+            url(s): (`str` or `list` or `dict`), URL(s) to stream data from matching the given input `url_or_urls`.
+        """
+        return self.extract(self.download(url_or_urls))
+
+    def iter_archive(self, urlpath_or_buf: Union[str, io.BufferedReader]) -> Iterable[Tuple]:
+        """Iterate over files within an archive.
+
+        Args:
+            urlpath_or_buf (`str` or `io.BufferedReader`):
+                Archive path or archive binary file object.
+
+        Yields:
+            `tuple[str, io.BufferedReader]`:
+                2-tuple (path_within_archive, file_object).
+                File object is opened in binary mode.
+
+        Example:
+
+        ```py
+        >>> archive = dl_manager.download('https://storage.googleapis.com/seldon-datasets/sentence_polarity_v1/rt-polaritydata.tar.gz')
+        >>> files = dl_manager.iter_archive(archive)
+        ```
+        """
+
+        if hasattr(urlpath_or_buf, "read"):
+            return ArchiveIterable.from_buf(urlpath_or_buf)
+        else:
+            return ArchiveIterable.from_urlpath(urlpath_or_buf, download_config=self.download_config)
+
+    def iter_files(self, urlpaths: Union[str, List[str]]) -> Iterable[str]:
+        """Iterate over files.
+
+        Args:
+            urlpaths (`str` or `list` of `str`):
+                Root paths.
+
+        Yields:
+            str: File URL path.
+
+        Example:
+
+        ```py
+        >>> files = dl_manager.download_and_extract('https://huggingface.co/datasets/beans/resolve/main/data/train.zip')
+        >>> files = dl_manager.iter_files(files)
+        ```
+        """
+        return FilesIterable.from_urlpaths(urlpaths, download_config=self.download_config)

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

@@ -0,0 +1,131 @@
+# 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.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}'"
+        )

env-llmeval/lib/python3.10/site-packages/datasets/formatting/formatting.py

@@ -0,0 +1,649 @@
+# 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.
+
+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)):
+        _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

env-llmeval/lib/python3.10/site-packages/datasets/formatting/jax_formatter.py

@@ -0,0 +1,160 @@
+# Copyright 2021 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.
+
+# Lint as: python3
+import sys
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Dict, Optional
+
+import numpy as np
+import pyarrow as pa
+
+from .. import config
+from ..utils.logging import get_logger
+from ..utils.py_utils import map_nested
+from .formatting import TensorFormatter
+
+
+if TYPE_CHECKING:
+    import jax
+    import jaxlib
+
+logger = get_logger()
+
+DEVICE_MAPPING: Optional[dict] = None
+
+
+class JaxFormatter(TensorFormatter[Mapping, "jax.Array", Mapping]):
+    def __init__(self, features=None, device=None, **jnp_array_kwargs):
+        super().__init__(features=features)
+        import jax
+        from jaxlib.xla_client import Device
+
+        if isinstance(device, Device):
+            raise ValueError(
+                f"Expected {device} to be a `str` not {type(device)}, as `jaxlib.xla_extension.Device` "
+                "is not serializable neither with `pickle` nor with `dill`. Instead you can surround "
+                "the device with `str()` to get its string identifier that will be internally mapped "
+                "to the actual `jaxlib.xla_extension.Device`."
+            )
+        self.device = device if isinstance(device, str) else str(jax.devices()[0])
+        # using global variable since `jaxlib.xla_extension.Device` is not serializable neither
+        # with `pickle` nor with `dill`, so we need to use a global variable instead
+        global DEVICE_MAPPING
+        if DEVICE_MAPPING is None:
+            DEVICE_MAPPING = self._map_devices_to_str()
+        if self.device not in list(DEVICE_MAPPING.keys()):
+            logger.warning(
+                f"Device with string identifier {self.device} not listed among the available "
+                f"devices: {list(DEVICE_MAPPING.keys())}, so falling back to the default "
+                f"device: {str(jax.devices()[0])}."
+            )
+            self.device = str(jax.devices()[0])
+        self.jnp_array_kwargs = jnp_array_kwargs
+
+    @staticmethod
+    def _map_devices_to_str() -> Dict[str, "jaxlib.xla_extension.Device"]:
+        import jax
+
+        return {str(device): device for device in jax.devices()}
+
+    def _consolidate(self, column):
+        import jax
+        import jax.numpy as jnp
+
+        if isinstance(column, list) and column:
+            if all(
+                isinstance(x, jax.Array) and x.shape == column[0].shape and x.dtype == column[0].dtype for x in column
+            ):
+                return jnp.stack(column, axis=0)
+        return column
+
+    def _tensorize(self, value):
+        import jax
+        import jax.numpy as jnp
+
+        if isinstance(value, (str, bytes, type(None))):
+            return value
+        elif isinstance(value, (np.character, np.ndarray)) and np.issubdtype(value.dtype, np.character):
+            return value.tolist()
+
+        default_dtype = {}
+
+        if isinstance(value, (np.number, np.ndarray)) and np.issubdtype(value.dtype, np.integer):
+            # the default int precision depends on the jax config
+            # see https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#double-64bit-precision
+            if jax.config.jax_enable_x64:
+                default_dtype = {"dtype": jnp.int64}
+            else:
+                default_dtype = {"dtype": jnp.int32}
+        elif isinstance(value, (np.number, np.ndarray)) and np.issubdtype(value.dtype, np.floating):
+            default_dtype = {"dtype": jnp.float32}
+        elif config.PIL_AVAILABLE and "PIL" in sys.modules:
+            import PIL.Image
+
+            if isinstance(value, PIL.Image.Image):
+                value = np.asarray(value)
+
+        # using global variable since `jaxlib.xla_extension.Device` is not serializable neither
+        # with `pickle` nor with `dill`, so we need to use a global variable instead
+        global DEVICE_MAPPING
+        if DEVICE_MAPPING is None:
+            DEVICE_MAPPING = self._map_devices_to_str()
+
+        with jax.default_device(DEVICE_MAPPING[self.device]):
+            # calling jnp.array on a np.ndarray does copy the data
+            # see https://github.com/google/jax/issues/4486
+            return jnp.array(value, **{**default_dtype, **self.jnp_array_kwargs})
+
+    def _recursive_tensorize(self, data_struct):
+        import jax
+
+        # support for torch, tf, jax etc.
+        if config.TORCH_AVAILABLE and "torch" in sys.modules:
+            import torch
+
+            if isinstance(data_struct, torch.Tensor):
+                return self._tensorize(data_struct.detach().cpu().numpy()[()])
+        if hasattr(data_struct, "__array__") and not isinstance(data_struct, jax.Array):
+            data_struct = data_struct.__array__()
+        # support for nested types like struct of list of struct
+        if isinstance(data_struct, np.ndarray):
+            if data_struct.dtype == object:  # jax arrays cannot be instantied from an array of objects
+                return self._consolidate([self.recursive_tensorize(substruct) for substruct in data_struct])
+        elif isinstance(data_struct, (list, tuple)):
+            return self._consolidate([self.recursive_tensorize(substruct) for substruct in data_struct])
+        return self._tensorize(data_struct)
+
+    def recursive_tensorize(self, data_struct: dict):
+        return map_nested(self._recursive_tensorize, data_struct, map_list=False)
+
+    def format_row(self, pa_table: pa.Table) -> Mapping:
+        row = self.numpy_arrow_extractor().extract_row(pa_table)
+        row = self.python_features_decoder.decode_row(row)
+        return self.recursive_tensorize(row)
+
+    def format_column(self, pa_table: pa.Table) -> "jax.Array":
+        column = self.numpy_arrow_extractor().extract_column(pa_table)
+        column = self.python_features_decoder.decode_column(column, pa_table.column_names[0])
+        column = self.recursive_tensorize(column)
+        column = self._consolidate(column)
+        return column
+
+    def format_batch(self, pa_table: pa.Table) -> Mapping:
+        batch = self.numpy_arrow_extractor().extract_batch(pa_table)
+        batch = self.python_features_decoder.decode_batch(batch)
+        batch = self.recursive_tensorize(batch)
+        for column_name in batch:
+            batch[column_name] = self._consolidate(batch[column_name])
+        return batch

env-llmeval/lib/python3.10/site-packages/datasets/formatting/np_formatter.py

@@ -0,0 +1,106 @@
+# 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 sys
+from collections.abc import Mapping
+
+import numpy as np
+import pyarrow as pa
+
+from .. import config
+from ..utils.py_utils import map_nested
+from .formatting import TensorFormatter
+
+
+class NumpyFormatter(TensorFormatter[Mapping, np.ndarray, Mapping]):
+    def __init__(self, features=None, **np_array_kwargs):
+        super().__init__(features=features)
+        self.np_array_kwargs = np_array_kwargs
+
+    def _consolidate(self, column):
+        if isinstance(column, list):
+            if column and all(
+                isinstance(x, np.ndarray) and x.shape == column[0].shape and x.dtype == column[0].dtype for x in column
+            ):
+                return np.stack(column)
+            else:
+                # don't use np.array(column, dtype=object)
+                # since it fails in certain cases
+                # see https://stackoverflow.com/q/51005699
+                out = np.empty(len(column), dtype=object)
+                out[:] = column
+                return out
+        return column
+
+    def _tensorize(self, value):
+        if isinstance(value, (str, bytes, type(None))):
+            return value
+        elif isinstance(value, (np.character, np.ndarray)) and np.issubdtype(value.dtype, np.character):
+            return value
+        elif isinstance(value, np.number):
+            return value
+
+        default_dtype = {}
+
+        if isinstance(value, np.ndarray) and np.issubdtype(value.dtype, np.integer):
+            default_dtype = {"dtype": np.int64}
+        elif isinstance(value, np.ndarray) and np.issubdtype(value.dtype, np.floating):
+            default_dtype = {"dtype": np.float32}
+        elif config.PIL_AVAILABLE and "PIL" in sys.modules:
+            import PIL.Image
+
+            if isinstance(value, PIL.Image.Image):
+                return np.asarray(value, **self.np_array_kwargs)
+
+        return np.asarray(value, **{**default_dtype, **self.np_array_kwargs})
+
+    def _recursive_tensorize(self, data_struct):
+        # support for torch, tf, jax etc.
+        if config.TORCH_AVAILABLE and "torch" in sys.modules:
+            import torch
+
+            if isinstance(data_struct, torch.Tensor):
+                return self._tensorize(data_struct.detach().cpu().numpy()[()])
+        if hasattr(data_struct, "__array__") and not isinstance(data_struct, (np.ndarray, np.character, np.number)):
+            data_struct = data_struct.__array__()
+        # support for nested types like struct of list of struct
+        if isinstance(data_struct, np.ndarray):
+            if data_struct.dtype == object:
+                return self._consolidate([self.recursive_tensorize(substruct) for substruct in data_struct])
+        if isinstance(data_struct, (list, tuple)):
+            return self._consolidate([self.recursive_tensorize(substruct) for substruct in data_struct])
+        return self._tensorize(data_struct)
+
+    def recursive_tensorize(self, data_struct: dict):
+        return map_nested(self._recursive_tensorize, data_struct, map_list=False)
+
+    def format_row(self, pa_table: pa.Table) -> Mapping:
+        row = self.numpy_arrow_extractor().extract_row(pa_table)
+        row = self.python_features_decoder.decode_row(row)
+        return self.recursive_tensorize(row)
+
+    def format_column(self, pa_table: pa.Table) -> np.ndarray:
+        column = self.numpy_arrow_extractor().extract_column(pa_table)
+        column = self.python_features_decoder.decode_column(column, pa_table.column_names[0])
+        column = self.recursive_tensorize(column)
+        column = self._consolidate(column)
+        return column
+
+    def format_batch(self, pa_table: pa.Table) -> Mapping:
+        batch = self.numpy_arrow_extractor().extract_batch(pa_table)
+        batch = self.python_features_decoder.decode_batch(batch)
+        batch = self.recursive_tensorize(batch)
+        for column_name in batch:
+            batch[column_name] = self._consolidate(batch[column_name])
+        return batch

env-llmeval/lib/python3.10/site-packages/datasets/formatting/tf_formatter.py

@@ -0,0 +1,115 @@
+# 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.
+
+# Lint as: python3
+import sys
+from collections.abc import Mapping
+from typing import TYPE_CHECKING
+
+import numpy as np
+import pyarrow as pa
+
+from .. import config
+from ..utils.py_utils import map_nested
+from .formatting import TensorFormatter
+
+
+if TYPE_CHECKING:
+    import tensorflow as tf
+
+
+class TFFormatter(TensorFormatter[Mapping, "tf.Tensor", Mapping]):
+    def __init__(self, features=None, **tf_tensor_kwargs):
+        super().__init__(features=features)
+        self.tf_tensor_kwargs = tf_tensor_kwargs
+        import tensorflow as tf  # noqa: F401 - import tf at initialization
+
+    def _consolidate(self, column):
+        import tensorflow as tf
+
+        if isinstance(column, list) and column:
+            if all(
+                isinstance(x, tf.Tensor) and x.shape == column[0].shape and x.dtype == column[0].dtype for x in column
+            ):
+                return tf.stack(column)
+            elif all(
+                isinstance(x, (tf.Tensor, tf.RaggedTensor)) and x.ndim == 1 and x.dtype == column[0].dtype
+                for x in column
+            ):
+                # only rag 1-D tensors, otherwise some dimensions become ragged even though they were consolidated
+                return tf.ragged.stack(column)
+
+        return column
+
+    def _tensorize(self, value):
+        import tensorflow as tf
+
+        if value is None:
+            return value
+
+        default_dtype = {}
+
+        if isinstance(value, (np.number, np.ndarray)) and np.issubdtype(value.dtype, np.integer):
+            default_dtype = {"dtype": tf.int64}
+        elif isinstance(value, (np.number, np.ndarray)) and np.issubdtype(value.dtype, np.floating):
+            default_dtype = {"dtype": tf.float32}
+        elif config.PIL_AVAILABLE and "PIL" in sys.modules:
+            import PIL.Image
+
+            if isinstance(value, PIL.Image.Image):
+                value = np.asarray(value)
+
+        return tf.convert_to_tensor(value, **{**default_dtype, **self.tf_tensor_kwargs})
+
+    def _recursive_tensorize(self, data_struct):
+        import tensorflow as tf
+
+        # support for torch, tf, jax etc.
+        if config.TORCH_AVAILABLE and "torch" in sys.modules:
+            import torch
+
+            if isinstance(data_struct, torch.Tensor):
+                return self._tensorize(data_struct.detach().cpu().numpy()[()])
+        if hasattr(data_struct, "__array__") and not isinstance(data_struct, tf.Tensor):
+            data_struct = data_struct.__array__()
+        # support for nested types like struct of list of struct
+        if isinstance(data_struct, np.ndarray):
+            if data_struct.dtype == object:  # tf tensors cannot be instantied from an array of objects
+                return self._consolidate([self.recursive_tensorize(substruct) for substruct in data_struct])
+        elif isinstance(data_struct, (list, tuple)):
+            return self._consolidate([self.recursive_tensorize(substruct) for substruct in data_struct])
+        return self._tensorize(data_struct)
+
+    def recursive_tensorize(self, data_struct: dict):
+        return map_nested(self._recursive_tensorize, data_struct, map_list=False)
+
+    def format_row(self, pa_table: pa.Table) -> Mapping:
+        row = self.numpy_arrow_extractor().extract_row(pa_table)
+        row = self.python_features_decoder.decode_row(row)
+        return self.recursive_tensorize(row)
+
+    def format_column(self, pa_table: pa.Table) -> "tf.Tensor":
+        column = self.numpy_arrow_extractor().extract_column(pa_table)
+        column = self.python_features_decoder.decode_column(column, pa_table.column_names[0])
+        column = self.recursive_tensorize(column)
+        column = self._consolidate(column)
+        return column
+
+    def format_batch(self, pa_table: pa.Table) -> Mapping:
+        batch = self.numpy_arrow_extractor().extract_batch(pa_table)
+        batch = self.python_features_decoder.decode_batch(batch)
+        batch = self.recursive_tensorize(batch)
+        for column_name in batch:
+            batch[column_name] = self._consolidate(batch[column_name])
+        return batch

env-llmeval/lib/python3.10/site-packages/datasets/formatting/torch_formatter.py

@@ -0,0 +1,111 @@
+# 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.
+
+# Lint as: python3
+import sys
+from collections.abc import Mapping
+from typing import TYPE_CHECKING
+
+import numpy as np
+import pyarrow as pa
+
+from .. import config
+from ..utils.py_utils import map_nested
+from .formatting import TensorFormatter
+
+
+if TYPE_CHECKING:
+    import torch
+
+
+class TorchFormatter(TensorFormatter[Mapping, "torch.Tensor", Mapping]):
+    def __init__(self, features=None, **torch_tensor_kwargs):
+        super().__init__(features=features)
+        self.torch_tensor_kwargs = torch_tensor_kwargs
+        import torch  # noqa import torch at initialization
+
+    def _consolidate(self, column):
+        import torch
+
+        if isinstance(column, list) and column:
+            if all(
+                isinstance(x, torch.Tensor) and x.shape == column[0].shape and x.dtype == column[0].dtype
+                for x in column
+            ):
+                return torch.stack(column)
+        return column
+
+    def _tensorize(self, value):
+        import torch
+
+        if isinstance(value, (str, bytes, type(None))):
+            return value
+        elif isinstance(value, (np.character, np.ndarray)) and np.issubdtype(value.dtype, np.character):
+            return value.tolist()
+
+        default_dtype = {}
+
+        if isinstance(value, (np.number, np.ndarray)) and np.issubdtype(value.dtype, np.integer):
+            default_dtype = {"dtype": torch.int64}
+
+            # Convert dtype to np.int64 if it's either np.uint16 or np.uint32 to ensure compatibility.
+            # np.uint64 is excluded from this conversion as there is no compatible PyTorch dtype that can handle it without loss.
+            if value.dtype in [np.uint16, np.uint32]:
+                value = value.astype(np.int64)
+
+        elif isinstance(value, (np.number, np.ndarray)) and np.issubdtype(value.dtype, np.floating):
+            default_dtype = {"dtype": torch.float32}
+        elif config.PIL_AVAILABLE and "PIL" in sys.modules:
+            import PIL.Image
+
+            if isinstance(value, PIL.Image.Image):
+                value = np.asarray(value)
+        return torch.tensor(value, **{**default_dtype, **self.torch_tensor_kwargs})
+
+    def _recursive_tensorize(self, data_struct):
+        import torch
+
+        # support for torch, tf, jax etc.
+        if hasattr(data_struct, "__array__") and not isinstance(data_struct, torch.Tensor):
+            data_struct = data_struct.__array__()
+        # support for nested types like struct of list of struct
+        if isinstance(data_struct, np.ndarray):
+            if data_struct.dtype == object:  # torch tensors cannot be instantied from an array of objects
+                return self._consolidate([self.recursive_tensorize(substruct) for substruct in data_struct])
+        elif isinstance(data_struct, (list, tuple)):
+            return self._consolidate([self.recursive_tensorize(substruct) for substruct in data_struct])
+        return self._tensorize(data_struct)
+
+    def recursive_tensorize(self, data_struct: dict):
+        return map_nested(self._recursive_tensorize, data_struct, map_list=False)
+
+    def format_row(self, pa_table: pa.Table) -> Mapping:
+        row = self.numpy_arrow_extractor().extract_row(pa_table)
+        row = self.python_features_decoder.decode_row(row)
+        return self.recursive_tensorize(row)
+
+    def format_column(self, pa_table: pa.Table) -> "torch.Tensor":
+        column = self.numpy_arrow_extractor().extract_column(pa_table)
+        column = self.python_features_decoder.decode_column(column, pa_table.column_names[0])
+        column = self.recursive_tensorize(column)
+        column = self._consolidate(column)
+        return column
+
+    def format_batch(self, pa_table: pa.Table) -> Mapping:
+        batch = self.numpy_arrow_extractor().extract_batch(pa_table)
+        batch = self.python_features_decoder.decode_batch(batch)
+        batch = self.recursive_tensorize(batch)
+        for column_name in batch:
+            batch[column_name] = self._consolidate(batch[column_name])
+        return batch

env-llmeval/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

env-llmeval/lib/python3.10/site-packages/datasets/packaged_modules/spark/spark.py

@@ -0,0 +1,349 @@
+import os
+import posixpath
+import uuid
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Iterable, List, Optional, Tuple, Union
+
+import numpy as np
+import pyarrow as pa
+
+import datasets
+from datasets.arrow_writer import ArrowWriter, ParquetWriter
+from datasets.config import MAX_SHARD_SIZE
+from datasets.filesystems import (
+    is_remote_filesystem,
+    rename,
+)
+from datasets.iterable_dataset import _BaseExamplesIterable
+from datasets.utils.py_utils import convert_file_size_to_int
+
+
+logger = datasets.utils.logging.get_logger(__name__)
+
+if TYPE_CHECKING:
+    import pyspark
+
+
+@dataclass
+class SparkConfig(datasets.BuilderConfig):
+    """BuilderConfig for Spark."""
+
+    features: Optional[datasets.Features] = None
+
+
+def _reorder_dataframe_by_partition(df: "pyspark.sql.DataFrame", new_partition_order: List[int]):
+    df_combined = df.select("*").where(f"part_id = {new_partition_order[0]}")
+    for partition_id in new_partition_order[1:]:
+        partition_df = df.select("*").where(f"part_id = {partition_id}")
+        df_combined = df_combined.union(partition_df)
+    return df_combined
+
+
+def _generate_iterable_examples(
+    df: "pyspark.sql.DataFrame",
+    partition_order: List[int],
+):
+    import pyspark
+
+    def generate_fn():
+        df_with_partition_id = df.select("*", pyspark.sql.functions.spark_partition_id().alias("part_id"))
+        partition_df = _reorder_dataframe_by_partition(df_with_partition_id, partition_order)
+        row_id = 0
+        # pipeline next partition in parallel to hide latency
+        rows = partition_df.toLocalIterator(prefetchPartitions=True)
+        curr_partition = -1
+        for row in rows:
+            row_as_dict = row.asDict()
+            part_id = row_as_dict["part_id"]
+            row_as_dict.pop("part_id")
+            if curr_partition != part_id:
+                curr_partition = part_id
+                row_id = 0
+            yield f"{part_id}_{row_id}", row_as_dict
+            row_id += 1
+
+    return generate_fn
+
+
+class SparkExamplesIterable(_BaseExamplesIterable):
+    def __init__(
+        self,
+        df: "pyspark.sql.DataFrame",
+        partition_order=None,
+    ):
+        self.df = df
+        self.partition_order = partition_order or range(self.df.rdd.getNumPartitions())
+        self.generate_examples_fn = _generate_iterable_examples(self.df, self.partition_order)
+
+    def __iter__(self):
+        yield from self.generate_examples_fn()
+
+    def shuffle_data_sources(self, generator: np.random.Generator) -> "SparkExamplesIterable":
+        partition_order = list(range(self.df.rdd.getNumPartitions()))
+        generator.shuffle(partition_order)
+        return SparkExamplesIterable(self.df, partition_order=partition_order)
+
+    def shard_data_sources(self, worker_id: int, num_workers: int) -> "SparkExamplesIterable":
+        partition_order = self.split_shard_indices_by_worker(worker_id, num_workers)
+        return SparkExamplesIterable(self.df, partition_order=partition_order)
+
+    @property
+    def n_shards(self) -> int:
+        return len(self.partition_order)
+
+
+class Spark(datasets.DatasetBuilder):
+    BUILDER_CONFIG_CLASS = SparkConfig
+
+    def __init__(
+        self,
+        df: "pyspark.sql.DataFrame",
+        cache_dir: str = None,
+        working_dir: str = None,
+        **config_kwargs,
+    ):
+        import pyspark
+
+        self._spark = pyspark.sql.SparkSession.builder.getOrCreate()
+        self.df = df
+        self._working_dir = working_dir
+
+        super().__init__(
+            cache_dir=cache_dir,
+            config_name=str(self.df.semanticHash()),
+            **config_kwargs,
+        )
+
+    def _validate_cache_dir(self):
+        # Define this so that we don't reference self in create_cache_and_write_probe, which will result in a pickling
+        # error due to pickling the SparkContext.
+        cache_dir = self._cache_dir
+
+        # Returns the path of the created file.
+        def create_cache_and_write_probe(context):
+            # makedirs with exist_ok will recursively create the directory. It will not throw an error if directories
+            # already exist.
+            os.makedirs(cache_dir, exist_ok=True)
+            probe_file = os.path.join(cache_dir, "fs_test" + uuid.uuid4().hex)
+            # Opening the file in append mode will create a new file unless it already exists, in which case it will not
+            # change the file contents.
+            open(probe_file, "a")
+            return [probe_file]
+
+        if self._spark.conf.get("spark.master", "").startswith("local"):
+            return
+
+        # If the cluster is multi-node, make sure that the user provided a cache_dir and that it is on an NFS
+        # accessible to the driver.
+        # TODO: Stream batches to the driver using ArrowCollectSerializer instead of throwing an error.
+        if self._cache_dir:
+            probe = (
+                self._spark.sparkContext.parallelize(range(1), 1).mapPartitions(create_cache_and_write_probe).collect()
+            )
+            if os.path.isfile(probe[0]):
+                return
+
+        raise ValueError(
+            "When using Dataset.from_spark on a multi-node cluster, the driver and all workers should be able to access cache_dir"
+        )
+
+    def _info(self):
+        return datasets.DatasetInfo(features=self.config.features)
+
+    def _split_generators(self, dl_manager: datasets.download.download_manager.DownloadManager):
+        return [datasets.SplitGenerator(name=datasets.Split.TRAIN)]
+
+    def _repartition_df_if_needed(self, max_shard_size):
+        import pyspark
+
+        def get_arrow_batch_size(it):
+            for batch in it:
+                yield pa.RecordBatch.from_pydict({"batch_bytes": [batch.nbytes]})
+
+        df_num_rows = self.df.count()
+        sample_num_rows = df_num_rows if df_num_rows <= 100 else 100
+        # Approximate the size of each row (in Arrow format) by averaging over a max-100-row sample.
+        approx_bytes_per_row = (
+            self.df.limit(sample_num_rows)
+            .repartition(1)
+            .mapInArrow(get_arrow_batch_size, "batch_bytes: long")
+            .agg(pyspark.sql.functions.sum("batch_bytes").alias("sample_bytes"))
+            .collect()[0]
+            .sample_bytes
+            / sample_num_rows
+        )
+        approx_total_size = approx_bytes_per_row * df_num_rows
+        if approx_total_size > max_shard_size:
+            # Make sure there is at least one row per partition.
+            new_num_partitions = min(df_num_rows, int(approx_total_size / max_shard_size))
+            self.df = self.df.repartition(new_num_partitions)
+
+    def _prepare_split_single(
+        self,
+        fpath: str,
+        file_format: str,
+        max_shard_size: int,
+    ) -> Iterable[Tuple[int, bool, Union[int, tuple]]]:
+        import pyspark
+
+        writer_class = ParquetWriter if file_format == "parquet" else ArrowWriter
+        working_fpath = os.path.join(self._working_dir, os.path.basename(fpath)) if self._working_dir else fpath
+        embed_local_files = file_format == "parquet"
+
+        # Define these so that we don't reference self in write_arrow, which will result in a pickling error due to
+        # pickling the SparkContext.
+        features = self.config.features
+        writer_batch_size = self._writer_batch_size
+        storage_options = self._fs.storage_options
+
+        def write_arrow(it):
+            # Within the same SparkContext, no two task attempts will share the same attempt ID.
+            task_id = pyspark.TaskContext().taskAttemptId()
+            first_batch = next(it, None)
+            if first_batch is None:
+                # Some partitions might not receive any data.
+                return pa.RecordBatch.from_arrays(
+                    [[task_id], [0], [0]],
+                    names=["task_id", "num_examples", "num_bytes"],
+                )
+            shard_id = 0
+            writer = writer_class(
+                features=features,
+                path=working_fpath.replace("SSSSS", f"{shard_id:05d}").replace("TTTTT", f"{task_id:05d}"),
+                writer_batch_size=writer_batch_size,
+                storage_options=storage_options,
+                embed_local_files=embed_local_files,
+            )
+            table = pa.Table.from_batches([first_batch])
+            writer.write_table(table)
+            for batch in it:
+                if max_shard_size is not None and writer._num_bytes >= max_shard_size:
+                    num_examples, num_bytes = writer.finalize()
+                    writer.close()
+                    yield pa.RecordBatch.from_arrays(
+                        [[task_id], [num_examples], [num_bytes]],
+                        names=["task_id", "num_examples", "num_bytes"],
+                    )
+                    shard_id += 1
+                    writer = writer_class(
+                        features=writer._features,
+                        path=working_fpath.replace("SSSSS", f"{shard_id:05d}").replace("TTTTT", f"{task_id:05d}"),
+                        writer_batch_size=writer_batch_size,
+                        storage_options=storage_options,
+                        embed_local_files=embed_local_files,
+                    )
+                table = pa.Table.from_batches([batch])
+                writer.write_table(table)
+
+            if writer._num_bytes > 0:
+                num_examples, num_bytes = writer.finalize()
+                writer.close()
+                yield pa.RecordBatch.from_arrays(
+                    [[task_id], [num_examples], [num_bytes]],
+                    names=["task_id", "num_examples", "num_bytes"],
+                )
+
+            if working_fpath != fpath:
+                for file in os.listdir(os.path.dirname(working_fpath)):
+                    dest = os.path.join(os.path.dirname(fpath), os.path.basename(file))
+                    shutil.move(file, dest)
+
+        stats = (
+            self.df.mapInArrow(write_arrow, "task_id: long, num_examples: long, num_bytes: long")
+            .groupBy("task_id")
+            .agg(
+                pyspark.sql.functions.sum("num_examples").alias("total_num_examples"),
+                pyspark.sql.functions.sum("num_bytes").alias("total_num_bytes"),
+                pyspark.sql.functions.count("num_bytes").alias("num_shards"),
+                pyspark.sql.functions.collect_list("num_examples").alias("shard_lengths"),
+            )
+            .collect()
+        )
+        for row in stats:
+            yield row.task_id, (row.total_num_examples, row.total_num_bytes, row.num_shards, row.shard_lengths)
+
+    def _prepare_split(
+        self,
+        split_generator: "datasets.SplitGenerator",
+        file_format: str = "arrow",
+        max_shard_size: Optional[Union[str, int]] = None,
+        num_proc: Optional[int] = None,
+        **kwargs,
+    ):
+        self._validate_cache_dir()
+
+        max_shard_size = convert_file_size_to_int(max_shard_size or MAX_SHARD_SIZE)
+        self._repartition_df_if_needed(max_shard_size)
+        is_local = not is_remote_filesystem(self._fs)
+        path_join = os.path.join if is_local else posixpath.join
+
+        SUFFIX = "-TTTTT-SSSSS-of-NNNNN"
+        fname = f"{self.name}-{split_generator.name}{SUFFIX}.{file_format}"
+        fpath = path_join(self._output_dir, fname)
+
+        total_num_examples = 0
+        total_num_bytes = 0
+        total_shards = 0
+        task_id_and_num_shards = []
+        all_shard_lengths = []
+
+        for task_id, content in self._prepare_split_single(fpath, file_format, max_shard_size):
+            (
+                num_examples,
+                num_bytes,
+                num_shards,
+                shard_lengths,
+            ) = content
+            if num_bytes > 0:
+                total_num_examples += num_examples
+                total_num_bytes += num_bytes
+                total_shards += num_shards
+                task_id_and_num_shards.append((task_id, num_shards))
+                all_shard_lengths.extend(shard_lengths)
+
+        split_generator.split_info.num_examples = total_num_examples
+        split_generator.split_info.num_bytes = total_num_bytes
+
+        # should rename everything at the end
+        logger.debug(f"Renaming {total_shards} shards.")
+        if total_shards > 1:
+            split_generator.split_info.shard_lengths = all_shard_lengths
+
+            # Define fs outside of _rename_shard so that we don't reference self in the function, which will result in a
+            # pickling error due to pickling the SparkContext.
+            fs = self._fs
+
+            # use the -SSSSS-of-NNNNN pattern
+            def _rename_shard(
+                task_id: int,
+                shard_id: int,
+                global_shard_id: int,
+            ):
+                rename(
+                    fs,
+                    fpath.replace("SSSSS", f"{shard_id:05d}").replace("TTTTT", f"{task_id:05d}"),
+                    fpath.replace("TTTTT-SSSSS", f"{global_shard_id:05d}").replace("NNNNN", f"{total_shards:05d}"),
+                )
+
+            args = []
+            global_shard_id = 0
+            for i in range(len(task_id_and_num_shards)):
+                task_id, num_shards = task_id_and_num_shards[i]
+                for shard_id in range(num_shards):
+                    args.append([task_id, shard_id, global_shard_id])
+                    global_shard_id += 1
+            self._spark.sparkContext.parallelize(args, len(args)).map(lambda args: _rename_shard(*args)).collect()
+        else:
+            # don't use any pattern
+            shard_id = 0
+            task_id = task_id_and_num_shards[0][0]
+            self._rename(
+                fpath.replace("SSSSS", f"{shard_id:05d}").replace("TTTTT", f"{task_id:05d}"),
+                fpath.replace(SUFFIX, ""),
+            )
+
+    def _get_examples_iterable_for_split(
+        self,
+        split_generator: "datasets.SplitGenerator",
+    ) -> SparkExamplesIterable:
+        return SparkExamplesIterable(self.df)

env-llmeval/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)