Add files using upload-large-folder tool

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

@@ -0,0 +1,70 @@
+# ruff: noqa
+# 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.
+
+__version__ = "2.19.1"
+
+from .arrow_dataset import Dataset
+from .arrow_reader import ReadInstruction
+from .builder import ArrowBasedBuilder, BeamBasedBuilder, BuilderConfig, DatasetBuilder, GeneratorBasedBuilder
+from .combine import concatenate_datasets, interleave_datasets
+from .dataset_dict import DatasetDict, IterableDatasetDict
+from .download import *
+from .features import *
+from .fingerprint import disable_caching, enable_caching, is_caching_enabled, set_caching_enabled
+from .info import DatasetInfo, MetricInfo
+from .inspect import (
+    get_dataset_config_info,
+    get_dataset_config_names,
+    get_dataset_default_config_name,
+    get_dataset_infos,
+    get_dataset_split_names,
+    inspect_dataset,
+    inspect_metric,
+    list_datasets,
+    list_metrics,
+)
+from .iterable_dataset import IterableDataset
+from .load import load_dataset, load_dataset_builder, load_from_disk, load_metric
+from .metric import Metric
+from .splits import (
+    NamedSplit,
+    NamedSplitAll,
+    Split,
+    SplitBase,
+    SplitDict,
+    SplitGenerator,
+    SplitInfo,
+    SubSplitInfo,
+    percent,
+)
+from .tasks import *
+from .utils import *
+from .utils import logging
+
+
+# deprecated modules
+from datasets import arrow_dataset as _arrow_dataset  # isort:skip
+from datasets import utils as _utils  # isort:skip
+from datasets.utils import download_manager as _deprecated_download_manager  # isort:skip
+
+_arrow_dataset.concatenate_datasets = concatenate_datasets
+_utils.DownloadConfig = DownloadConfig
+_utils.DownloadManager = DownloadManager
+_utils.DownloadMode = DownloadMode
+_deprecated_download_manager.DownloadConfig = DownloadConfig
+_deprecated_download_manager.DownloadMode = DownloadMode
+_deprecated_download_manager.DownloadManager = DownloadManager
+
+del _arrow_dataset, _utils, _deprecated_download_manager

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,821 @@
+import os
+import re
+from functools import partial
+from glob import has_magic
+from pathlib import Path, PurePath
+from typing import Callable, Dict, List, Optional, Set, Tuple, Union
+
+import huggingface_hub
+from fsspec.core import url_to_fs
+from fsspec.implementations.http import HTTPFileSystem
+from huggingface_hub import HfFileSystem
+from packaging import version
+from tqdm.contrib.concurrent import thread_map
+
+from . import config
+from .download import DownloadConfig
+from .naming import _split_re
+from .splits import Split
+from .utils import logging
+from .utils import tqdm as hf_tqdm
+from .utils.file_utils import _prepare_path_and_storage_options, is_local_path, is_relative_path, xbasename, xjoin
+from .utils.py_utils import glob_pattern_to_regex, string_to_dict
+
+
+SANITIZED_DEFAULT_SPLIT = str(Split.TRAIN)
+
+
+logger = logging.get_logger(__name__)
+
+
+class Url(str):
+    pass
+
+
+class EmptyDatasetError(FileNotFoundError):
+    pass
+
+
+SPLIT_PATTERN_SHARDED = "data/{split}-[0-9][0-9][0-9][0-9][0-9]-of-[0-9][0-9][0-9][0-9][0-9]*.*"
+
+SPLIT_KEYWORDS = {
+    Split.TRAIN: ["train", "training"],
+    Split.VALIDATION: ["validation", "valid", "dev", "val"],
+    Split.TEST: ["test", "testing", "eval", "evaluation"],
+}
+NON_WORDS_CHARS = "-._ 0-9"
+if config.FSSPEC_VERSION < version.parse("2023.9.0"):
+    KEYWORDS_IN_FILENAME_BASE_PATTERNS = ["**[{sep}/]{keyword}[{sep}]*", "{keyword}[{sep}]*"]
+    KEYWORDS_IN_DIR_NAME_BASE_PATTERNS = [
+        "{keyword}/**",
+        "{keyword}[{sep}]*/**",
+        "**[{sep}/]{keyword}/**",
+        "**[{sep}/]{keyword}[{sep}]*/**",
+    ]
+elif config.FSSPEC_VERSION < version.parse("2023.12.0"):
+    KEYWORDS_IN_FILENAME_BASE_PATTERNS = ["**/*[{sep}/]{keyword}[{sep}]*", "{keyword}[{sep}]*"]
+    KEYWORDS_IN_DIR_NAME_BASE_PATTERNS = [
+        "{keyword}/**/*",
+        "{keyword}[{sep}]*/**/*",
+        "**/*[{sep}/]{keyword}/**/*",
+        "**/*[{sep}/]{keyword}[{sep}]*/**/*",
+    ]
+else:
+    KEYWORDS_IN_FILENAME_BASE_PATTERNS = ["**/{keyword}[{sep}]*", "**/*[{sep}]{keyword}[{sep}]*"]
+    KEYWORDS_IN_DIR_NAME_BASE_PATTERNS = [
+        "**/{keyword}/**",
+        "**/{keyword}[{sep}]*/**",
+        "**/*[{sep}]{keyword}/**",
+        "**/*[{sep}]{keyword}[{sep}]*/**",
+    ]
+
+DEFAULT_SPLITS = [Split.TRAIN, Split.VALIDATION, Split.TEST]
+DEFAULT_PATTERNS_SPLIT_IN_FILENAME = {
+    split: [
+        pattern.format(keyword=keyword, sep=NON_WORDS_CHARS)
+        for keyword in SPLIT_KEYWORDS[split]
+        for pattern in KEYWORDS_IN_FILENAME_BASE_PATTERNS
+    ]
+    for split in DEFAULT_SPLITS
+}
+DEFAULT_PATTERNS_SPLIT_IN_DIR_NAME = {
+    split: [
+        pattern.format(keyword=keyword, sep=NON_WORDS_CHARS)
+        for keyword in SPLIT_KEYWORDS[split]
+        for pattern in KEYWORDS_IN_DIR_NAME_BASE_PATTERNS
+    ]
+    for split in DEFAULT_SPLITS
+}
+
+
+DEFAULT_PATTERNS_ALL = {
+    Split.TRAIN: ["**"],
+}
+
+ALL_SPLIT_PATTERNS = [SPLIT_PATTERN_SHARDED]
+ALL_DEFAULT_PATTERNS = [
+    DEFAULT_PATTERNS_SPLIT_IN_DIR_NAME,
+    DEFAULT_PATTERNS_SPLIT_IN_FILENAME,
+    DEFAULT_PATTERNS_ALL,
+]
+if config.FSSPEC_VERSION < version.parse("2023.9.0"):
+    METADATA_PATTERNS = [
+        "metadata.csv",
+        "**/metadata.csv",
+        "metadata.jsonl",
+        "**/metadata.jsonl",
+    ]  # metadata file for ImageFolder and AudioFolder
+else:
+    METADATA_PATTERNS = [
+        "**/metadata.csv",
+        "**/metadata.jsonl",
+    ]  # metadata file for ImageFolder and AudioFolder
+WILDCARD_CHARACTERS = "*[]"
+FILES_TO_IGNORE = [
+    "README.md",
+    "config.json",
+    "dataset_info.json",
+    "dataset_infos.json",
+    "dummy_data.zip",
+    "dataset_dict.json",
+]
+
+
+def contains_wildcards(pattern: str) -> bool:
+    return any(wilcard_character in pattern for wilcard_character in WILDCARD_CHARACTERS)
+
+
+def sanitize_patterns(patterns: Union[Dict, List, str]) -> Dict[str, Union[List[str], "DataFilesList"]]:
+    """
+    Take the data_files patterns from the user, and format them into a dictionary.
+    Each key is the name of the split, and each value is a list of data files patterns (paths or urls).
+    The default split is "train".
+
+    Returns:
+        patterns: dictionary of split_name -> list of patterns
+    """
+    if isinstance(patterns, dict):
+        return {str(key): value if isinstance(value, list) else [value] for key, value in patterns.items()}
+    elif isinstance(patterns, str):
+        return {SANITIZED_DEFAULT_SPLIT: [patterns]}
+    elif isinstance(patterns, list):
+        if any(isinstance(pattern, dict) for pattern in patterns):
+            for pattern in patterns:
+                if not (
+                    isinstance(pattern, dict)
+                    and len(pattern) == 2
+                    and "split" in pattern
+                    and isinstance(pattern.get("path"), (str, list))
+                ):
+                    raise ValueError(
+                        f"Expected each split to have a 'path' key which can be a string or a list of strings, but got {pattern}"
+                    )
+            splits = [pattern["split"] for pattern in patterns]
+            if len(set(splits)) != len(splits):
+                raise ValueError(f"Some splits are duplicated in data_files: {splits}")
+            return {
+                str(pattern["split"]): pattern["path"] if isinstance(pattern["path"], list) else [pattern["path"]]
+                for pattern in patterns
+            }
+        else:
+            return {SANITIZED_DEFAULT_SPLIT: patterns}
+    else:
+        return sanitize_patterns(list(patterns))
+
+
+def _is_inside_unrequested_special_dir(matched_rel_path: str, pattern: str) -> bool:
+    """
+    When a path matches a pattern, we additionnally check if it's inside a special directory
+    we ignore by default (if it starts with a double underscore).
+
+    Users can still explicitly request a filepath inside such a directory if "__pycache__" is
+    mentioned explicitly in the requested pattern.
+
+    Some examples:
+
+    base directory:
+
+        ./
+        └── __pycache__
+            └── b.txt
+
+    >>> _is_inside_unrequested_special_dir("__pycache__/b.txt", "**")
+    True
+    >>> _is_inside_unrequested_special_dir("__pycache__/b.txt", "*/b.txt")
+    True
+    >>> _is_inside_unrequested_special_dir("__pycache__/b.txt", "__pycache__/*")
+    False
+    >>> _is_inside_unrequested_special_dir("__pycache__/b.txt", "__*/*")
+    False
+    """
+    # We just need to check if every special directories from the path is present explicly in the pattern.
+    # Since we assume that the path matches the pattern, it's equivalent to counting that both
+    # the parent path and the parent pattern have the same number of special directories.
+    data_dirs_to_ignore_in_path = [part for part in PurePath(matched_rel_path).parent.parts if part.startswith("__")]
+    data_dirs_to_ignore_in_pattern = [part for part in PurePath(pattern).parent.parts if part.startswith("__")]
+    return len(data_dirs_to_ignore_in_path) != len(data_dirs_to_ignore_in_pattern)
+
+
+def _is_unrequested_hidden_file_or_is_inside_unrequested_hidden_dir(matched_rel_path: str, pattern: str) -> bool:
+    """
+    When a path matches a pattern, we additionnally check if it's a hidden file or if it's inside
+    a hidden directory we ignore by default, i.e. if the file name or a parent directory name starts with a dot.
+
+    Users can still explicitly request a filepath that is hidden or is inside a hidden directory
+    if the hidden part is mentioned explicitly in the requested pattern.
+
+    Some examples:
+
+    base directory:
+
+        ./
+        └── .hidden_file.txt
+
+    >>> _is_unrequested_hidden_file_or_is_inside_unrequested_hidden_dir(".hidden_file.txt", "**")
+    True
+    >>> _is_unrequested_hidden_file_or_is_inside_unrequested_hidden_dir(".hidden_file.txt", ".*")
+    False
+
+    base directory:
+
+        ./
+        └── .hidden_dir
+            └── a.txt
+
+    >>> _is_unrequested_hidden_file_or_is_inside_unrequested_hidden_dir(".hidden_dir/a.txt", "**")
+    True
+    >>> _is_unrequested_hidden_file_or_is_inside_unrequested_hidden_dir(".hidden_dir/a.txt", ".*/*")
+    False
+    >>> _is_unrequested_hidden_file_or_is_inside_unrequested_hidden_dir(".hidden_dir/a.txt", ".hidden_dir/*")
+    False
+
+    base directory:
+
+        ./
+        └── .hidden_dir
+            └── .hidden_file.txt
+
+    >>> _is_unrequested_hidden_file_or_is_inside_unrequested_hidden_dir(".hidden_dir/.hidden_file.txt", "**")
+    True
+    >>> _is_unrequested_hidden_file_or_is_inside_unrequested_hidden_dir(".hidden_dir/.hidden_file.txt", ".*/*")
+    True
+    >>> _is_unrequested_hidden_file_or_is_inside_unrequested_hidden_dir(".hidden_dir/.hidden_file.txt", ".*/.*")
+    False
+    >>> _is_unrequested_hidden_file_or_is_inside_unrequested_hidden_dir(".hidden_dir/.hidden_file.txt", ".hidden_dir/*")
+    True
+    >>> _is_unrequested_hidden_file_or_is_inside_unrequested_hidden_dir(".hidden_dir/.hidden_file.txt", ".hidden_dir/.*")
+    False
+    """
+    # We just need to check if every hidden part from the path is present explicly in the pattern.
+    # Since we assume that the path matches the pattern, it's equivalent to counting that both
+    # the path and the pattern have the same number of hidden parts.
+    hidden_directories_in_path = [
+        part for part in PurePath(matched_rel_path).parts if part.startswith(".") and not set(part) == {"."}
+    ]
+    hidden_directories_in_pattern = [
+        part for part in PurePath(pattern).parts if part.startswith(".") and not set(part) == {"."}
+    ]
+    return len(hidden_directories_in_path) != len(hidden_directories_in_pattern)
+
+
+def _get_data_files_patterns(pattern_resolver: Callable[[str], List[str]]) -> Dict[str, List[str]]:
+    """
+    Get the default pattern from a directory or repository by testing all the supported patterns.
+    The first patterns to return a non-empty list of data files is returned.
+
+    In order, it first tests if SPLIT_PATTERN_SHARDED works, otherwise it tests the patterns in ALL_DEFAULT_PATTERNS.
+    """
+    # first check the split patterns like data/{split}-00000-of-00001.parquet
+    for split_pattern in ALL_SPLIT_PATTERNS:
+        pattern = split_pattern.replace("{split}", "*")
+        try:
+            data_files = pattern_resolver(pattern)
+        except FileNotFoundError:
+            continue
+        if len(data_files) > 0:
+            splits: Set[str] = {
+                string_to_dict(xbasename(p), glob_pattern_to_regex(xbasename(split_pattern)))["split"]
+                for p in data_files
+            }
+            if any(not re.match(_split_re, split) for split in splits):
+                raise ValueError(f"Split name should match '{_split_re}'' but got '{splits}'.")
+            sorted_splits = [str(split) for split in DEFAULT_SPLITS if split in splits] + sorted(
+                splits - set(DEFAULT_SPLITS)
+            )
+            return {split: [split_pattern.format(split=split)] for split in sorted_splits}
+    # then check the default patterns based on train/valid/test splits
+    for patterns_dict in ALL_DEFAULT_PATTERNS:
+        non_empty_splits = []
+        for split, patterns in patterns_dict.items():
+            for pattern in patterns:
+                try:
+                    data_files = pattern_resolver(pattern)
+                except FileNotFoundError:
+                    continue
+                if len(data_files) > 0:
+                    non_empty_splits.append(split)
+                    break
+        if non_empty_splits:
+            return {split: patterns_dict[split] for split in non_empty_splits}
+    raise FileNotFoundError(f"Couldn't resolve pattern {pattern} with resolver {pattern_resolver}")
+
+
+def _get_metadata_files_patterns(pattern_resolver: Callable[[str], List[str]]) -> List[str]:
+    """
+    Get the supported metadata patterns from a directory or repository.
+    """
+    non_empty_patterns = []
+    for pattern in METADATA_PATTERNS:
+        try:
+            metadata_files = pattern_resolver(pattern)
+            if len(metadata_files) > 0:
+                non_empty_patterns.append(pattern)
+        except FileNotFoundError:
+            pass
+    if non_empty_patterns:
+        return non_empty_patterns
+    raise FileNotFoundError(f"Couldn't resolve pattern {pattern} with resolver {pattern_resolver}")
+
+
+def resolve_pattern(
+    pattern: str,
+    base_path: str,
+    allowed_extensions: Optional[List[str]] = None,
+    download_config: Optional[DownloadConfig] = None,
+) -> List[str]:
+    """
+    Resolve the paths and URLs of the data files from the pattern passed by the user.
+
+    You can use patterns to resolve multiple local files. Here are a few examples:
+    - *.csv to match all the CSV files at the first level
+    - **.csv to match all the CSV files at any level
+    - data/* to match all the files inside "data"
+    - data/** to match all the files inside "data" and its subdirectories
+
+    The patterns are resolved using the fsspec glob. In fsspec>=2023.12.0 this is equivalent to
+    Python's glob.glob, Path.glob, Path.match and fnmatch where ** is unsupported with a prefix/suffix
+    other than a forward slash /.
+
+    More generally:
+    - '*' matches any character except a forward-slash (to match just the file or directory name)
+    - '**' matches any character including a forward-slash /
+
+    Hidden files and directories (i.e. whose names start with a dot) are ignored, unless they are explicitly requested.
+    The same applies to special directories that start with a double underscore like "__pycache__".
+    You can still include one if the pattern explicilty mentions it:
+    - to include a hidden file: "*/.hidden.txt" or "*/.*"
+    - to include a hidden directory: ".hidden/*" or ".*/*"
+    - to include a special directory: "__special__/*" or "__*/*"
+
+    Example::
+
+        >>> from datasets.data_files import resolve_pattern
+        >>> base_path = "."
+        >>> resolve_pattern("docs/**/*.py", base_path)
+        [/Users/mariosasko/Desktop/projects/datasets/docs/source/_config.py']
+
+    Args:
+        pattern (str): Unix pattern or paths or URLs of the data files to resolve.
+            The paths can be absolute or relative to base_path.
+            Remote filesystems using fsspec are supported, e.g. with the hf:// protocol.
+        base_path (str): Base path to use when resolving relative paths.
+        allowed_extensions (Optional[list], optional): White-list of file extensions to use. Defaults to None (all extensions).
+            For example: allowed_extensions=[".csv", ".json", ".txt", ".parquet"]
+    Returns:
+        List[str]: List of paths or URLs to the local or remote files that match the patterns.
+    """
+    if is_relative_path(pattern):
+        pattern = xjoin(base_path, pattern)
+    elif is_local_path(pattern):
+        base_path = os.path.splitdrive(pattern)[0] + os.sep
+    else:
+        base_path = ""
+    pattern, storage_options = _prepare_path_and_storage_options(pattern, download_config=download_config)
+    fs, fs_pattern = url_to_fs(pattern, **storage_options)
+    files_to_ignore = set(FILES_TO_IGNORE) - {xbasename(pattern)}
+    protocol = fs.protocol if isinstance(fs.protocol, str) else fs.protocol[0]
+    protocol_prefix = protocol + "://" if protocol != "file" else ""
+    glob_kwargs = {}
+    if protocol == "hf" and config.HF_HUB_VERSION >= version.parse("0.20.0"):
+        # 10 times faster glob with detail=True (ignores costly info like lastCommit)
+        glob_kwargs["expand_info"] = False
+    matched_paths = [
+        filepath if filepath.startswith(protocol_prefix) else protocol_prefix + filepath
+        for filepath, info in fs.glob(pattern, detail=True, **glob_kwargs).items()
+        if info["type"] == "file"
+        and (xbasename(filepath) not in files_to_ignore)
+        and not _is_inside_unrequested_special_dir(filepath, fs_pattern)
+        and not _is_unrequested_hidden_file_or_is_inside_unrequested_hidden_dir(filepath, fs_pattern)
+    ]  # ignore .ipynb and __pycache__, but keep /../
+    if allowed_extensions is not None:
+        out = [
+            filepath
+            for filepath in matched_paths
+            if any("." + suffix in allowed_extensions for suffix in xbasename(filepath).split(".")[1:])
+        ]
+        if len(out) < len(matched_paths):
+            invalid_matched_files = list(set(matched_paths) - set(out))
+            logger.info(
+                f"Some files matched the pattern '{pattern}' but don't have valid data file extensions: {invalid_matched_files}"
+            )
+    else:
+        out = matched_paths
+    if not out:
+        error_msg = f"Unable to find '{pattern}'"
+        if allowed_extensions is not None:
+            error_msg += f" with any supported extension {list(allowed_extensions)}"
+        raise FileNotFoundError(error_msg)
+    return out
+
+
+def get_data_patterns(base_path: str, download_config: Optional[DownloadConfig] = None) -> Dict[str, List[str]]:
+    """
+    Get the default pattern from a directory testing all the supported patterns.
+    The first patterns to return a non-empty list of data files is returned.
+
+    Some examples of supported patterns:
+
+    Input:
+
+        my_dataset_repository/
+        ├── README.md
+        └── dataset.csv
+
+    Output:
+
+        {'train': ['**']}
+
+    Input:
+
+        my_dataset_repository/
+        ├── README.md
+        ├── train.csv
+        └── test.csv
+
+        my_dataset_repository/
+        ├── README.md
+        └── data/
+            ├── train.csv
+            └── test.csv
+
+        my_dataset_repository/
+        ├── README.md
+        ├── train_0.csv
+        ├── train_1.csv
+        ├── train_2.csv
+        ├── train_3.csv
+        ├── test_0.csv
+        └── test_1.csv
+
+    Output:
+
+        {'train': ['**/train[-._ 0-9]*', '**/*[-._ 0-9]train[-._ 0-9]*', '**/training[-._ 0-9]*', '**/*[-._ 0-9]training[-._ 0-9]*'],
+         'test': ['**/test[-._ 0-9]*', '**/*[-._ 0-9]test[-._ 0-9]*', '**/testing[-._ 0-9]*', '**/*[-._ 0-9]testing[-._ 0-9]*', ...]}
+
+    Input:
+
+        my_dataset_repository/
+        ├── README.md
+        └── data/
+            ├── train/
+            │   ├── shard_0.csv
+            │   ├── shard_1.csv
+            │   ├── shard_2.csv
+            │   └── shard_3.csv
+            └── test/
+                ├── shard_0.csv
+                └── shard_1.csv
+
+    Output:
+
+        {'train': ['**/train/**', '**/train[-._ 0-9]*/**', '**/*[-._ 0-9]train/**', '**/*[-._ 0-9]train[-._ 0-9]*/**', ...],
+         'test': ['**/test/**', '**/test[-._ 0-9]*/**', '**/*[-._ 0-9]test/**', '**/*[-._ 0-9]test[-._ 0-9]*/**', ...]}
+
+    Input:
+
+        my_dataset_repository/
+        ├── README.md
+        └── data/
+            ├── train-00000-of-00003.csv
+            ├── train-00001-of-00003.csv
+            ├── train-00002-of-00003.csv
+            ├── test-00000-of-00001.csv
+            ├── random-00000-of-00003.csv
+            ├── random-00001-of-00003.csv
+            └── random-00002-of-00003.csv
+
+    Output:
+
+        {'train': ['data/train-[0-9][0-9][0-9][0-9][0-9]-of-[0-9][0-9][0-9][0-9][0-9]*.*'],
+         'test': ['data/test-[0-9][0-9][0-9][0-9][0-9]-of-[0-9][0-9][0-9][0-9][0-9]*.*'],
+         'random': ['data/random-[0-9][0-9][0-9][0-9][0-9]-of-[0-9][0-9][0-9][0-9][0-9]*.*']}
+
+    In order, it first tests if SPLIT_PATTERN_SHARDED works, otherwise it tests the patterns in ALL_DEFAULT_PATTERNS.
+    """
+    resolver = partial(resolve_pattern, base_path=base_path, download_config=download_config)
+    try:
+        return _get_data_files_patterns(resolver)
+    except FileNotFoundError:
+        raise EmptyDatasetError(f"The directory at {base_path} doesn't contain any data files") from None
+
+
+def get_metadata_patterns(
+    base_path: str,
+    download_config: Optional[DownloadConfig] = None,
+) -> List[str]:
+    """
+    Get the supported metadata patterns from a local directory.
+    """
+    resolver = partial(resolve_pattern, base_path=base_path, download_config=download_config)
+    try:
+        return _get_metadata_files_patterns(resolver)
+    except FileNotFoundError:
+        raise FileNotFoundError(f"The directory at {base_path} doesn't contain any metadata file") from None
+
+
+def _get_single_origin_metadata(
+    data_file: str,
+    download_config: Optional[DownloadConfig] = None,
+) -> Tuple[str]:
+    data_file, storage_options = _prepare_path_and_storage_options(data_file, download_config=download_config)
+    fs, *_ = url_to_fs(data_file, **storage_options)
+    if isinstance(fs, HfFileSystem):
+        resolved_path = fs.resolve_path(data_file)
+        return (resolved_path.repo_id, resolved_path.revision)
+    elif isinstance(fs, HTTPFileSystem) and data_file.startswith(config.HF_ENDPOINT):
+        hffs = HfFileSystem(endpoint=config.HF_ENDPOINT, token=download_config.token)
+        data_file = "hf://" + data_file[len(config.HF_ENDPOINT) + 1 :].replace("/resolve/", "@", 1)
+        resolved_path = hffs.resolve_path(data_file)
+        return (resolved_path.repo_id, resolved_path.revision)
+    info = fs.info(data_file)
+    # s3fs uses "ETag", gcsfs uses "etag", and for local we simply check mtime
+    for key in ["ETag", "etag", "mtime"]:
+        if key in info:
+            return (str(info[key]),)
+    return ()
+
+
+def _get_origin_metadata(
+    data_files: List[str],
+    download_config: Optional[DownloadConfig] = None,
+    max_workers: Optional[int] = None,
+) -> Tuple[str]:
+    max_workers = max_workers if max_workers is not None else config.HF_DATASETS_MULTITHREADING_MAX_WORKERS
+    return thread_map(
+        partial(_get_single_origin_metadata, download_config=download_config),
+        data_files,
+        max_workers=max_workers,
+        tqdm_class=hf_tqdm,
+        desc="Resolving data files",
+        # set `disable=None` rather than `disable=False` by default to disable progress bar when no TTY attached
+        disable=len(data_files) <= 16 or None,
+    )
+
+
+class DataFilesList(List[str]):
+    """
+    List of data files (absolute local paths or URLs).
+    It has two construction methods given the user's data files patterns :
+    - ``from_hf_repo``: resolve patterns inside a dataset repository
+    - ``from_local_or_remote``: resolve patterns from a local path
+
+    Moreover DataFilesList has an additional attribute ``origin_metadata``.
+    It can store:
+    - the last modified time of local files
+    - ETag of remote files
+    - commit sha of a dataset repository
+
+    Thanks to this additional attribute, it is possible to hash the list
+    and get a different hash if and only if at least one file changed.
+    This is useful for caching Dataset objects that are obtained from a list of data files.
+    """
+
+    def __init__(self, data_files: List[str], origin_metadata: List[Tuple[str]]):
+        super().__init__(data_files)
+        self.origin_metadata = origin_metadata
+
+    def __add__(self, other):
+        return DataFilesList([*self, *other], self.origin_metadata + other.origin_metadata)
+
+    @classmethod
+    def from_hf_repo(
+        cls,
+        patterns: List[str],
+        dataset_info: huggingface_hub.hf_api.DatasetInfo,
+        base_path: Optional[str] = None,
+        allowed_extensions: Optional[List[str]] = None,
+        download_config: Optional[DownloadConfig] = None,
+    ) -> "DataFilesList":
+        base_path = f"hf://datasets/{dataset_info.id}@{dataset_info.sha}/{base_path or ''}".rstrip("/")
+        return cls.from_patterns(
+            patterns, base_path=base_path, allowed_extensions=allowed_extensions, download_config=download_config
+        )
+
+    @classmethod
+    def from_local_or_remote(
+        cls,
+        patterns: List[str],
+        base_path: Optional[str] = None,
+        allowed_extensions: Optional[List[str]] = None,
+        download_config: Optional[DownloadConfig] = None,
+    ) -> "DataFilesList":
+        base_path = base_path if base_path is not None else Path().resolve().as_posix()
+        return cls.from_patterns(
+            patterns, base_path=base_path, allowed_extensions=allowed_extensions, download_config=download_config
+        )
+
+    @classmethod
+    def from_patterns(
+        cls,
+        patterns: List[str],
+        base_path: Optional[str] = None,
+        allowed_extensions: Optional[List[str]] = None,
+        download_config: Optional[DownloadConfig] = None,
+    ) -> "DataFilesList":
+        base_path = base_path if base_path is not None else Path().resolve().as_posix()
+        data_files = []
+        for pattern in patterns:
+            try:
+                data_files.extend(
+                    resolve_pattern(
+                        pattern,
+                        base_path=base_path,
+                        allowed_extensions=allowed_extensions,
+                        download_config=download_config,
+                    )
+                )
+            except FileNotFoundError:
+                if not has_magic(pattern):
+                    raise
+        origin_metadata = _get_origin_metadata(data_files, download_config=download_config)
+        return cls(data_files, origin_metadata)
+
+    def filter_extensions(self, extensions: List[str]) -> "DataFilesList":
+        pattern = "|".join("\\" + ext for ext in extensions)
+        pattern = re.compile(f".*({pattern})(\\..+)?$")
+        return DataFilesList(
+            [data_file for data_file in self if pattern.match(data_file)],
+            origin_metadata=self.origin_metadata,
+        )
+
+
+class DataFilesDict(Dict[str, DataFilesList]):
+    """
+    Dict of split_name -> list of data files (absolute local paths or URLs).
+    It has two construction methods given the user's data files patterns :
+    - ``from_hf_repo``: resolve patterns inside a dataset repository
+    - ``from_local_or_remote``: resolve patterns from a local path
+
+    Moreover each list is a DataFilesList. It is possible to hash the dictionary
+    and get a different hash if and only if at least one file changed.
+    For more info, see ``DataFilesList``.
+
+    This is useful for caching Dataset objects that are obtained from a list of data files.
+
+    Changing the order of the keys of this dictionary also doesn't change its hash.
+    """
+
+    @classmethod
+    def from_local_or_remote(
+        cls,
+        patterns: Dict[str, Union[List[str], DataFilesList]],
+        base_path: Optional[str] = None,
+        allowed_extensions: Optional[List[str]] = None,
+        download_config: Optional[DownloadConfig] = None,
+    ) -> "DataFilesDict":
+        out = cls()
+        for key, patterns_for_key in patterns.items():
+            out[key] = (
+                DataFilesList.from_local_or_remote(
+                    patterns_for_key,
+                    base_path=base_path,
+                    allowed_extensions=allowed_extensions,
+                    download_config=download_config,
+                )
+                if not isinstance(patterns_for_key, DataFilesList)
+                else patterns_for_key
+            )
+        return out
+
+    @classmethod
+    def from_hf_repo(
+        cls,
+        patterns: Dict[str, Union[List[str], DataFilesList]],
+        dataset_info: huggingface_hub.hf_api.DatasetInfo,
+        base_path: Optional[str] = None,
+        allowed_extensions: Optional[List[str]] = None,
+        download_config: Optional[DownloadConfig] = None,
+    ) -> "DataFilesDict":
+        out = cls()
+        for key, patterns_for_key in patterns.items():
+            out[key] = (
+                DataFilesList.from_hf_repo(
+                    patterns_for_key,
+                    dataset_info=dataset_info,
+                    base_path=base_path,
+                    allowed_extensions=allowed_extensions,
+                    download_config=download_config,
+                )
+                if not isinstance(patterns_for_key, DataFilesList)
+                else patterns_for_key
+            )
+        return out
+
+    @classmethod
+    def from_patterns(
+        cls,
+        patterns: Dict[str, Union[List[str], DataFilesList]],
+        base_path: Optional[str] = None,
+        allowed_extensions: Optional[List[str]] = None,
+        download_config: Optional[DownloadConfig] = None,
+    ) -> "DataFilesDict":
+        out = cls()
+        for key, patterns_for_key in patterns.items():
+            out[key] = (
+                DataFilesList.from_patterns(
+                    patterns_for_key,
+                    base_path=base_path,
+                    allowed_extensions=allowed_extensions,
+                    download_config=download_config,
+                )
+                if not isinstance(patterns_for_key, DataFilesList)
+                else patterns_for_key
+            )
+        return out
+
+    def filter_extensions(self, extensions: List[str]) -> "DataFilesDict":
+        out = type(self)()
+        for key, data_files_list in self.items():
+            out[key] = data_files_list.filter_extensions(extensions)
+        return out
+
+
+class DataFilesPatternsList(List[str]):
+    """
+    List of data files patterns (absolute local paths or URLs).
+    For each pattern there should also be a list of allowed extensions
+    to keep, or a None ot keep all the files for the pattern.
+    """
+
+    def __init__(
+        self,
+        patterns: List[str],
+        allowed_extensions: List[Optional[List[str]]],
+    ):
+        super().__init__(patterns)
+        self.allowed_extensions = allowed_extensions
+
+    def __add__(self, other):
+        return DataFilesList([*self, *other], self.allowed_extensions + other.allowed_extensions)
+
+    @classmethod
+    def from_patterns(
+        cls, patterns: List[str], allowed_extensions: Optional[List[str]] = None
+    ) -> "DataFilesPatternsDict":
+        return cls(patterns, [allowed_extensions] * len(patterns))
+
+    def resolve(
+        self,
+        base_path: str,
+        download_config: Optional[DownloadConfig] = None,
+    ) -> "DataFilesList":
+        base_path = base_path if base_path is not None else Path().resolve().as_posix()
+        data_files = []
+        for pattern, allowed_extensions in zip(self, self.allowed_extensions):
+            try:
+                data_files.extend(
+                    resolve_pattern(
+                        pattern,
+                        base_path=base_path,
+                        allowed_extensions=allowed_extensions,
+                        download_config=download_config,
+                    )
+                )
+            except FileNotFoundError:
+                if not has_magic(pattern):
+                    raise
+        origin_metadata = _get_origin_metadata(data_files, download_config=download_config)
+        return DataFilesList(data_files, origin_metadata)
+
+    def filter_extensions(self, extensions: List[str]) -> "DataFilesList":
+        return DataFilesPatternsList(
+            self, [allowed_extensions + extensions for allowed_extensions in self.allowed_extensions]
+        )
+
+
+class DataFilesPatternsDict(Dict[str, DataFilesPatternsList]):
+    """
+    Dict of split_name -> list of data files patterns (absolute local paths or URLs).
+    """
+
+    @classmethod
+    def from_patterns(
+        cls, patterns: Dict[str, List[str]], allowed_extensions: Optional[List[str]] = None
+    ) -> "DataFilesPatternsDict":
+        out = cls()
+        for key, patterns_for_key in patterns.items():
+            out[key] = (
+                DataFilesPatternsList.from_patterns(
+                    patterns_for_key,
+                    allowed_extensions=allowed_extensions,
+                )
+                if not isinstance(patterns_for_key, DataFilesPatternsList)
+                else patterns_for_key
+            )
+        return out
+
+    def resolve(
+        self,
+        base_path: str,
+        download_config: Optional[DownloadConfig] = None,
+    ) -> "DataFilesDict":
+        out = DataFilesDict()
+        for key, data_files_patterns_list in self.items():
+            out[key] = data_files_patterns_list.resolve(base_path, download_config)
+        return out
+
+    def filter_extensions(self, extensions: List[str]) -> "DataFilesPatternsDict":
+        out = type(self)()
+        for key, data_files_patterns_list in self.items():
+            out[key] = data_files_patterns_list.filter_extensions(extensions)
+        return out

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

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

@@ -0,0 +1,108 @@
+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.
+        extract_on_the_fly (`bool`, defaults to `False`):
+            If `True`, extract compressed files while they are being read.
+        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.
+        disable_tqdm (`bool`, defaults to `False`):
+            Whether to disable the individual files download progress bar
+    """
+
+    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
+    extract_on_the_fly: 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
+    disable_tqdm: bool = False
+
+    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)

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

@@ -0,0 +1,448 @@
+# 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 multiprocessing
+import os
+import posixpath
+import warnings
+from datetime import datetime
+from functools import partial
+from typing import Dict, List, Optional, Union
+
+import fsspec
+from fsspec.core import url_to_fs
+from tqdm.contrib.concurrent import thread_map
+
+from .. import config
+from ..utils import tqdm as hf_tqdm
+from ..utils.deprecation_utils import DeprecatedEnum, deprecated
+from ..utils.file_utils import (
+    ArchiveIterable,
+    FilesIterable,
+    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, tqdm
+from ..utils.py_utils import NestedDataStructure, map_nested, size_str
+from ..utils.track import tracked_str
+from .download_config import DownloadConfig
+
+
+logger = get_logger(__name__)
+
+
+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."
+
+
+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_batched, 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",
+                batched=True,
+                batch_size=-1,
+            )
+        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_batched(
+        self,
+        url_or_filenames: List[str],
+        download_config: DownloadConfig,
+    ) -> List[str]:
+        if len(url_or_filenames) >= 16:
+            download_config = download_config.copy()
+            download_config.disable_tqdm = True
+            download_func = partial(self._download_single, download_config=download_config)
+
+            fs: fsspec.AbstractFileSystem
+            fs, path = url_to_fs(url_or_filenames[0], **download_config.storage_options)
+            size = 0
+            try:
+                size = fs.info(path).get("size", 0)
+            except Exception:
+                pass
+            max_workers = (
+                config.HF_DATASETS_MULTITHREADING_MAX_WORKERS if size < (20 << 20) else 1
+            )  # enable multithreading if files are small
+
+            return thread_map(
+                download_func,
+                url_or_filenames,
+                desc=download_config.download_desc or "Downloading",
+                unit="files",
+                position=multiprocessing.current_process()._identity[-1]  # contains the ranks of subprocesses
+                if os.environ.get("HF_DATASETS_STACK_MULTIPROCESSING_DOWNLOAD_PROGRESS_BARS") == "1"
+                and multiprocessing.current_process()._identity
+                else None,
+                max_workers=max_workers,
+                tqdm_class=tqdm,
+            )
+        else:
+            return [
+                self._download_single(url_or_filename, download_config=download_config)
+                for url_or_filename in url_or_filenames
+            ]
+
+    def _download_single(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_urlpath(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_urlpaths(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_single, 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()

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

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

@@ -0,0 +1,210 @@
+import io
+import os
+from typing import Iterable, List, Optional, Tuple, Union
+
+from ..utils.file_utils import (  # noqa: F401 # backward compatibility
+    SINGLE_FILE_COMPRESSION_PROTOCOLS,
+    ArchiveIterable,
+    FilesIterable,
+    _get_extraction_protocol,
+    _get_path_extension,
+    _prepare_path_and_storage_options,
+    is_relative_path,
+    url_or_path_join,
+    xbasename,
+    xdirname,
+    xet_parse,
+    xexists,
+    xgetsize,
+    xglob,
+    xgzip_open,
+    xisdir,
+    xisfile,
+    xjoin,
+    xlistdir,
+    xnumpy_load,
+    xopen,
+    xpandas_read_csv,
+    xpandas_read_excel,
+    xPath,
+    xpyarrow_parquet_read_table,
+    xrelpath,
+    xsio_loadmat,
+    xsplit,
+    xsplitext,
+    xwalk,
+    xxml_dom_minidom_parse,
+)
+from ..utils.logging import get_logger
+from ..utils.py_utils import map_nested
+from .download_config import DownloadConfig
+
+
+logger = get_logger(__name__)
+
+
+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_single, url_or_urls, map_tuple=True)
+        return url_or_urls
+
+    def _download_single(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)

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

@@ -0,0 +1,69 @@
+import importlib
+import shutil
+import warnings
+from typing import List
+
+import fsspec
+import fsspec.asyn
+from fsspec.implementations.local import LocalFileSystem
+
+from ..utils.deprecation_utils import deprecated
+from . import compression
+
+
+_has_s3fs = importlib.util.find_spec("s3fs") is not None
+
+if _has_s3fs:
+    from .s3filesystem import S3FileSystem  # noqa: F401
+
+COMPRESSION_FILESYSTEMS: List[compression.BaseCompressedFileFileSystem] = [
+    compression.Bz2FileSystem,
+    compression.GzipFileSystem,
+    compression.Lz4FileSystem,
+    compression.XzFileSystem,
+    compression.ZstdFileSystem,
+]
+
+# Register custom filesystems
+for fs_class in COMPRESSION_FILESYSTEMS:
+    if fs_class.protocol in fsspec.registry and fsspec.registry[fs_class.protocol] is not fs_class:
+        warnings.warn(f"A filesystem protocol was already set for {fs_class.protocol} and will be overwritten.")
+    fsspec.register_implementation(fs_class.protocol, fs_class, clobber=True)
+
+
+@deprecated(
+    "This function is deprecated and will be removed in a future version. Please use `fsspec.core.strip_protocol` instead."
+)
+def extract_path_from_uri(dataset_path: str) -> str:
+    """
+    Preprocesses `dataset_path` and removes remote filesystem (e.g. removing `s3://`).
+
+    Args:
+        dataset_path (`str`):
+            Path (e.g. `dataset/train`) or remote uri (e.g. `s3://my-bucket/dataset/train`) of the dataset directory.
+    """
+    if "://" in dataset_path:
+        dataset_path = dataset_path.split("://")[1]
+    return dataset_path
+
+
+def is_remote_filesystem(fs: fsspec.AbstractFileSystem) -> bool:
+    """
+    Checks if `fs` is a remote filesystem.
+
+    Args:
+        fs (`fsspec.spec.AbstractFileSystem`):
+            An abstract super-class for pythonic file-systems, e.g. `fsspec.filesystem(\'file\')` or [`datasets.filesystems.S3FileSystem`].
+    """
+    return not isinstance(fs, LocalFileSystem)
+
+
+def rename(fs: fsspec.AbstractFileSystem, src: str, dst: str):
+    """
+    Renames the file `src` in `fs` to `dst`.
+    """
+    if not is_remote_filesystem(fs):
+        # LocalFileSystem.mv does copy + rm, it is more efficient to simply move a local directory
+        shutil.move(fs._strip_protocol(src), fs._strip_protocol(dst))
+    else:
+        fs.mv(src, dst, recursive=True)

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

@@ -0,0 +1,123 @@
+import os
+from typing import Optional
+
+import fsspec
+from fsspec.archive import AbstractArchiveFileSystem
+
+
+class BaseCompressedFileFileSystem(AbstractArchiveFileSystem):
+    """Read contents of compressed file as a filesystem with one file inside."""
+
+    root_marker = ""
+    protocol: str = (
+        None  # protocol passed in prefix to the url. ex: "gzip", for gzip://file.txt::http://foo.bar/file.txt.gz
+    )
+    compression: str = None  # compression type in fsspec. ex: "gzip"
+    extension: str = None  # extension of the filename to strip. ex: "".gz" to get file.txt from file.txt.gz
+
+    def __init__(
+        self, fo: str = "", target_protocol: Optional[str] = None, target_options: Optional[dict] = None, **kwargs
+    ):
+        """
+        The compressed file system can be instantiated from any compressed file.
+        It reads the contents of compressed file as a filesystem with one file inside, as if it was an archive.
+
+        The single file inside the filesystem is named after the compresssed file,
+        without the compression extension at the end of the filename.
+
+        Args:
+            fo (:obj:``str``): Path to compressed file. Will fetch file using ``fsspec.open()``
+            mode (:obj:``str``): Currently, only 'rb' accepted
+            target_protocol(:obj:``str``, optional): To override the FS protocol inferred from a URL.
+            target_options (:obj:``dict``, optional): Kwargs passed when instantiating the target FS.
+        """
+        super().__init__(self, **kwargs)
+        # always open as "rb" since fsspec can then use the TextIOWrapper to make it work for "r" mode
+        self.file = fsspec.open(
+            fo,
+            mode="rb",
+            protocol=target_protocol,
+            compression=self.compression,
+            client_kwargs={
+                "requote_redirect_url": False,  # see https://github.com/huggingface/datasets/pull/5459
+                "trust_env": True,  # Enable reading proxy env variables.
+                **(target_options or {}).pop("client_kwargs", {}),  # To avoid issues if it was already passed.
+            },
+            **(target_options or {}),
+        )
+        self.compressed_name = os.path.basename(self.file.path.split("::")[0])
+        self.uncompressed_name = (
+            self.compressed_name[: self.compressed_name.rindex(".")]
+            if "." in self.compressed_name
+            else self.compressed_name
+        )
+        self.dir_cache = None
+
+    @classmethod
+    def _strip_protocol(cls, path):
+        # compressed file paths are always relative to the archive root
+        return super()._strip_protocol(path).lstrip("/")
+
+    def _get_dirs(self):
+        if self.dir_cache is None:
+            f = {**self.file.fs.info(self.file.path), "name": self.uncompressed_name}
+            self.dir_cache = {f["name"]: f}
+
+    def cat(self, path: str):
+        return self.file.open().read()
+
+    def _open(
+        self,
+        path: str,
+        mode: str = "rb",
+        block_size=None,
+        autocommit=True,
+        cache_options=None,
+        **kwargs,
+    ):
+        path = self._strip_protocol(path)
+        if mode != "rb":
+            raise ValueError(f"Tried to read with mode {mode} on file {self.file.path} opened with mode 'rb'")
+        return self.file.open()
+
+
+class Bz2FileSystem(BaseCompressedFileFileSystem):
+    """Read contents of BZ2 file as a filesystem with one file inside."""
+
+    protocol = "bz2"
+    compression = "bz2"
+    extension = ".bz2"
+
+
+class GzipFileSystem(BaseCompressedFileFileSystem):
+    """Read contents of GZIP file as a filesystem with one file inside."""
+
+    protocol = "gzip"
+    compression = "gzip"
+    extension = ".gz"
+
+
+class Lz4FileSystem(BaseCompressedFileFileSystem):
+    """Read contents of LZ4 file as a filesystem with one file inside."""
+
+    protocol = "lz4"
+    compression = "lz4"
+    extension = ".lz4"
+
+
+class XzFileSystem(BaseCompressedFileFileSystem):
+    """Read contents of .xz (LZMA) file as a filesystem with one file inside."""
+
+    protocol = "xz"
+    compression = "xz"
+    extension = ".xz"
+
+
+class ZstdFileSystem(BaseCompressedFileFileSystem):
+    """
+    Read contents of .zstd file as a filesystem with one file inside.
+    """
+
+    protocol = "zstd"
+    compression = "zstd"
+    extension = ".zst"

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

@@ -0,0 +1,116 @@
+import s3fs
+
+from ..utils.deprecation_utils import deprecated
+
+
+@deprecated("Use s3fs.S3FileSystem instead.")
+class S3FileSystem(s3fs.S3FileSystem):
+    """
+    `datasets.filesystems.S3FileSystem` is a subclass of [`s3fs.S3FileSystem`](https://s3fs.readthedocs.io/en/latest/api.html).
+
+    Users can use this class to access S3 as if it were a file system. It exposes a filesystem-like API (ls, cp, open, etc.) on top of S3 storage. Provide credentials either explicitly (`key=`, `secret=`) or with boto's credential methods. See botocore documentation for more information. If no credentials are available, use `anon=True`.
+
+    Args:
+        anon (`bool`, default to `False`):
+            Whether to use anonymous connection (public buckets only). If `False`, uses the key/secret given,
+            or boto's credential resolver (client_kwargs, environment, variables, config files, EC2 IAM server, in that order).
+        key (`str`):
+            If not anonymous, use this access key ID, if specified.
+        secret (`str`):
+            If not anonymous, use this secret access key, if specified.
+        token (`str`):
+            If not anonymous, use this security token, if specified.
+        use_ssl (`bool`, defaults to `True`):
+            Whether to use SSL in connections to S3; may be faster without, but insecure. If `use_ssl` is
+            also set in `client_kwargs`, the value set in `client_kwargs` will take priority.
+        s3_additional_kwargs (`dict`):
+            Parameters that are used when calling S3 API methods. Typically used for things
+            like ServerSideEncryption.
+        client_kwargs (`dict`):
+            Parameters for the botocore client.
+        requester_pays (`bool`, defaults to `False`):
+            Whether `RequesterPays` buckets are supported.
+        default_block_size (`int`):
+            If given, the default block size value used for `open()`, if no specific value is given at all time.
+            The built-in default is 5MB.
+        default_fill_cache (`bool`, defaults to `True`):
+            Whether to use cache filling with open by default. Refer to `S3File.open`.
+        default_cache_type (`str`, defaults to `bytes`):
+            If given, the default `cache_type` value used for `open()`. Set to `none` if no
+            caching is desired. See fsspec's documentation for other available `cache_type` values.
+        version_aware (`bool`, defaults to `False`):
+            Whether to support bucket versioning. If enable this will require the user to have
+            the necessary IAM permissions for dealing with versioned objects.
+        cache_regions (`bool`, defaults to `False`):
+            Whether to cache bucket regions. Whenever a new bucket is used, it will
+            first find out which region it belongs to and then use the client for that region.
+        asynchronous (`bool`, defaults to `False`):
+            Whether this instance is to be used from inside coroutines.
+        config_kwargs (`dict`):
+            Parameters passed to `botocore.client.Config`.
+        **kwargs:
+            Other parameters for core session.
+        session (`aiobotocore.session.AioSession`):
+            Session to be used for all connections. This session will be used inplace of creating
+            a new session inside S3FileSystem. For example: `aiobotocore.session.AioSession(profile='test_user')`.
+        skip_instance_cache (`bool`):
+            Control reuse of instances. Passed on to `fsspec`.
+        use_listings_cache (`bool`):
+            Control reuse of directory listings. Passed on to `fsspec`.
+        listings_expiry_time (`int` or `float`):
+            Control reuse of directory listings. Passed on to `fsspec`.
+        max_paths (`int`): Control reuse of directory listings. Passed on to `fsspec`.
+
+    Examples:
+
+    Listing files from public S3 bucket.
+
+    ```py
+    >>> import datasets
+    >>> s3 = datasets.filesystems.S3FileSystem(anon=True)  # doctest: +SKIP
+    >>> s3.ls('public-datasets/imdb/train')  # doctest: +SKIP
+    ['dataset_info.json.json','dataset.arrow','state.json']
+    ```
+
+    Listing files from private S3 bucket using `aws_access_key_id` and `aws_secret_access_key`.
+
+    ```py
+    >>> import datasets
+    >>> s3 = datasets.filesystems.S3FileSystem(key=aws_access_key_id, secret=aws_secret_access_key)  # doctest: +SKIP
+    >>> s3.ls('my-private-datasets/imdb/train')  # doctest: +SKIP
+    ['dataset_info.json.json','dataset.arrow','state.json']
+    ```
+
+    Using `S3Filesystem` with `botocore.session.Session` and custom `aws_profile`.
+
+    ```py
+    >>> import botocore
+    >>> from datasets.filesystems import S3Filesystem
+
+    >>> s3_session = botocore.session.Session(profile_name='my_profile_name')
+    >>> s3 = S3FileSystem(session=s3_session)  # doctest: +SKIP
+    ```
+
+    Loading dataset from S3 using `S3Filesystem` and [`load_from_disk`].
+
+    ```py
+    >>> from datasets import load_from_disk
+    >>> from datasets.filesystems import S3Filesystem
+
+    >>> s3 = S3FileSystem(key=aws_access_key_id, secret=aws_secret_access_key)  # doctest: +SKIP
+    >>> dataset = load_from_disk('s3://my-private-datasets/imdb/train', storage_options=s3.storage_options)  # doctest: +SKIP
+    >>> print(len(dataset))
+    25000
+    ```
+
+    Saving dataset to S3 using `S3Filesystem` and [`Dataset.save_to_disk`].
+
+    ```py
+    >>> from datasets import load_dataset
+    >>> from datasets.filesystems import S3Filesystem
+
+    >>> dataset = load_dataset("imdb")
+    >>> s3 = S3FileSystem(key=aws_access_key_id, secret=aws_secret_access_key)  # doctest: +SKIP
+    >>> dataset.save_to_disk('s3://my-private-datasets/imdb/train', storage_options=s3.storage_options)  # doctest: +SKIP
+    ```
+    """

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

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

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

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

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

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

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

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

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

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

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

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