Add files using upload-large-folder tool

ckpts/universal/global_step20/zero/15.mlp.dense_h_to_4h_swiglu.weight/exp_avg.pt

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

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

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

ckpts/universal/global_step20/zero/18.attention.dense.weight/exp_avg.pt

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

ckpts/universal/global_step20/zero/18.attention.dense.weight/fp32.pt

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

ckpts/universal/global_step20/zero/9.mlp.dense_4h_to_h.weight/fp32.pt

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

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

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

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

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

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

venv/lib/python3.10/site-packages/datasets/packaged_modules/cache/cache.py

@@ -0,0 +1,207 @@
+import glob
+import json
+import os
+import shutil
+import time
+import warnings
+from pathlib import Path
+from typing import List, Optional, Tuple, Union
+
+import pyarrow as pa
+
+import datasets
+import datasets.config
+import datasets.data_files
+from datasets.naming import camelcase_to_snakecase, filenames_for_dataset_split
+
+
+logger = datasets.utils.logging.get_logger(__name__)
+
+
+def _get_modification_time(cached_directory_path):
+    return (Path(cached_directory_path)).stat().st_mtime
+
+
+def _find_hash_in_cache(
+    dataset_name: str,
+    config_name: Optional[str],
+    cache_dir: Optional[str],
+    config_kwargs: dict,
+    custom_features: Optional[datasets.Features],
+) -> Tuple[str, str, str]:
+    if config_name or config_kwargs or custom_features:
+        config_id = datasets.BuilderConfig(config_name or "default").create_config_id(
+            config_kwargs=config_kwargs, custom_features=custom_features
+        )
+    else:
+        config_id = None
+    cache_dir = os.path.expanduser(str(cache_dir or datasets.config.HF_DATASETS_CACHE))
+    namespace_and_dataset_name = dataset_name.split("/")
+    namespace_and_dataset_name[-1] = camelcase_to_snakecase(namespace_and_dataset_name[-1])
+    cached_relative_path = "___".join(namespace_and_dataset_name)
+    cached_datasets_directory_path_root = os.path.join(cache_dir, cached_relative_path)
+    cached_directory_paths = [
+        cached_directory_path
+        for cached_directory_path in glob.glob(
+            os.path.join(cached_datasets_directory_path_root, config_id or "*", "*", "*")
+        )
+        if os.path.isdir(cached_directory_path)
+        and (
+            config_kwargs
+            or custom_features
+            or json.loads(Path(cached_directory_path, "dataset_info.json").read_text(encoding="utf-8"))["config_name"]
+            == Path(cached_directory_path).parts[-3]  # no extra params => config_id == config_name
+        )
+    ]
+    if not cached_directory_paths:
+        cached_directory_paths = [
+            cached_directory_path
+            for cached_directory_path in glob.glob(os.path.join(cached_datasets_directory_path_root, "*", "*", "*"))
+            if os.path.isdir(cached_directory_path)
+        ]
+        available_configs = sorted(
+            {Path(cached_directory_path).parts[-3] for cached_directory_path in cached_directory_paths}
+        )
+        raise ValueError(
+            f"Couldn't find cache for {dataset_name}"
+            + (f" for config '{config_id}'" if config_id else "")
+            + (f"\nAvailable configs in the cache: {available_configs}" if available_configs else "")
+        )
+    # get most recent
+    cached_directory_path = Path(sorted(cached_directory_paths, key=_get_modification_time)[-1])
+    version, hash = cached_directory_path.parts[-2:]
+    other_configs = [
+        Path(_cached_directory_path).parts[-3]
+        for _cached_directory_path in glob.glob(os.path.join(cached_datasets_directory_path_root, "*", version, hash))
+        if os.path.isdir(_cached_directory_path)
+        and (
+            config_kwargs
+            or custom_features
+            or json.loads(Path(_cached_directory_path, "dataset_info.json").read_text(encoding="utf-8"))["config_name"]
+            == Path(_cached_directory_path).parts[-3]  # no extra params => config_id == config_name
+        )
+    ]
+    if not config_id and len(other_configs) > 1:
+        raise ValueError(
+            f"There are multiple '{dataset_name}' configurations in the cache: {', '.join(other_configs)}"
+            f"\nPlease specify which configuration to reload from the cache, e.g."
+            f"\n\tload_dataset('{dataset_name}', '{other_configs[0]}')"
+        )
+    config_name = cached_directory_path.parts[-3]
+    warning_msg = (
+        f"Found the latest cached dataset configuration '{config_name}' at {cached_directory_path} "
+        f"(last modified on {time.ctime(_get_modification_time(cached_directory_path))})."
+    )
+    logger.warning(warning_msg)
+    return config_name, version, hash
+
+
+class Cache(datasets.ArrowBasedBuilder):
+    def __init__(
+        self,
+        cache_dir: Optional[str] = None,
+        dataset_name: Optional[str] = None,
+        config_name: Optional[str] = None,
+        version: Optional[str] = "0.0.0",
+        hash: Optional[str] = None,
+        base_path: Optional[str] = None,
+        info: Optional[datasets.DatasetInfo] = None,
+        features: Optional[datasets.Features] = None,
+        token: Optional[Union[bool, str]] = None,
+        use_auth_token="deprecated",
+        repo_id: Optional[str] = None,
+        data_files: Optional[Union[str, list, dict, datasets.data_files.DataFilesDict]] = None,
+        data_dir: Optional[str] = None,
+        storage_options: Optional[dict] = None,
+        writer_batch_size: Optional[int] = None,
+        name="deprecated",
+        **config_kwargs,
+    ):
+        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,
+            )
+            token = use_auth_token
+        if name != "deprecated":
+            warnings.warn(
+                "Parameter 'name' was renamed to 'config_name' in version 2.3.0 and will be removed in 3.0.0.",
+                category=FutureWarning,
+            )
+            config_name = name
+        if repo_id is None and dataset_name is None:
+            raise ValueError("repo_id or dataset_name is required for the Cache dataset builder")
+        if data_files is not None:
+            config_kwargs["data_files"] = data_files
+        if data_dir is not None:
+            config_kwargs["data_dir"] = data_dir
+        if hash == "auto" and version == "auto":
+            config_name, version, hash = _find_hash_in_cache(
+                dataset_name=repo_id or dataset_name,
+                config_name=config_name,
+                cache_dir=cache_dir,
+                config_kwargs=config_kwargs,
+                custom_features=features,
+            )
+        elif hash == "auto" or version == "auto":
+            raise NotImplementedError("Pass both hash='auto' and version='auto' instead")
+        super().__init__(
+            cache_dir=cache_dir,
+            dataset_name=dataset_name,
+            config_name=config_name,
+            version=version,
+            hash=hash,
+            base_path=base_path,
+            info=info,
+            token=token,
+            repo_id=repo_id,
+            storage_options=storage_options,
+            writer_batch_size=writer_batch_size,
+        )
+
+    def _info(self) -> datasets.DatasetInfo:
+        return datasets.DatasetInfo()
+
+    def download_and_prepare(self, output_dir: Optional[str] = None, *args, **kwargs):
+        if not os.path.exists(self.cache_dir):
+            raise ValueError(f"Cache directory for {self.dataset_name} doesn't exist at {self.cache_dir}")
+        if output_dir is not None and output_dir != self.cache_dir:
+            shutil.copytree(self.cache_dir, output_dir)
+
+    def _split_generators(self, dl_manager):
+        # used to stream from cache
+        if isinstance(self.info.splits, datasets.SplitDict):
+            split_infos: List[datasets.SplitInfo] = list(self.info.splits.values())
+        else:
+            raise ValueError(f"Missing splits info for {self.dataset_name} in cache directory {self.cache_dir}")
+        return [
+            datasets.SplitGenerator(
+                name=split_info.name,
+                gen_kwargs={
+                    "files": filenames_for_dataset_split(
+                        self.cache_dir,
+                        dataset_name=self.dataset_name,
+                        split=split_info.name,
+                        filetype_suffix="arrow",
+                        shard_lengths=split_info.shard_lengths,
+                    )
+                },
+            )
+            for split_info in split_infos
+        ]
+
+    def _generate_tables(self, files):
+        # used to stream from cache
+        for file_idx, file in enumerate(files):
+            with open(file, "rb") as f:
+                try:
+                    for batch_idx, record_batch in enumerate(pa.ipc.open_stream(f)):
+                        pa_table = pa.Table.from_batches([record_batch])
+                        # Uncomment for debugging (will print the Arrow table size and elements)
+                        # logger.warning(f"pa_table: {pa_table} num rows: {pa_table.num_rows}")
+                        # logger.warning('\n'.join(str(pa_table.slice(i, 1).to_pydict()) for i in range(pa_table.num_rows)))
+                        yield f"{file_idx}_{batch_idx}", pa_table
+                except ValueError as e:
+                    logger.error(f"Failed to read file '{file}' with error {type(e)}: {e}")
+                    raise

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

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

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

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

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

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

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

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

venv/lib/python3.10/site-packages/datasets/packaged_modules/webdataset/_tenbin.py

@@ -0,0 +1,285 @@
+#
+# Copyright (c) 2017-2021 NVIDIA CORPORATION. All rights reserved.
+# This file coems from the WebDataset library.
+# See the LICENSE file for licensing terms (BSD-style).
+#
+
+"""
+Binary tensor encodings for PyTorch and NumPy.
+
+This defines efficient binary encodings for tensors. The format is 8 byte
+aligned and can be used directly for computations when transmitted, say,
+via RDMA. The format is supported by WebDataset with the `.ten` filename
+extension. It is also used by Tensorcom, Tensorcom RDMA, and can be used
+for fast tensor storage with LMDB and in disk files (which can be memory
+mapped)
+
+Data is encoded as a series of chunks:
+
+- magic number (int64)
+- length in bytes (int64)
+- bytes (multiple of 64 bytes long)
+
+Arrays are a header chunk followed by a data chunk.
+Header chunks have the following structure:
+
+- dtype (int64)
+- 8 byte array name
+- ndim (int64)
+- dim[0]
+- dim[1]
+- ...
+"""
+
+import struct
+import sys
+
+import numpy as np
+
+
+def bytelen(a):
+    """Determine the length of a in bytes."""
+    if hasattr(a, "nbytes"):
+        return a.nbytes
+    elif isinstance(a, (bytearray, bytes)):
+        return len(a)
+    else:
+        raise ValueError(a, "cannot determine nbytes")
+
+
+def bytedata(a):
+    """Return a the raw data corresponding to a."""
+    if isinstance(a, (bytearray, bytes, memoryview)):
+        return a
+    elif hasattr(a, "data"):
+        return a.data
+    else:
+        raise ValueError(a, "cannot return bytedata")
+
+
+# tables for converting between long/short NumPy dtypes
+
+long_to_short = """
+float16 f2
+float32 f4
+float64 f8
+int8 i1
+int16 i2
+int32 i4
+int64 i8
+uint8 u1
+uint16 u2
+unit32 u4
+uint64 u8
+""".strip()
+long_to_short = [x.split() for x in long_to_short.split("\n")]
+long_to_short = {x[0]: x[1] for x in long_to_short}
+short_to_long = {v: k for k, v in long_to_short.items()}
+
+
+def check_acceptable_input_type(data, allow64):
+    """Check that the data has an acceptable type for tensor encoding.
+
+    :param data: array
+    :param allow64: allow 64 bit types
+    """
+    for a in data:
+        if a.dtype.name not in long_to_short:
+            raise ValueError("unsupported dataypte")
+        if not allow64 and a.dtype.name not in ["float64", "int64", "uint64"]:
+            raise ValueError("64 bit datatypes not allowed unless explicitly enabled")
+
+
+def str64(s):
+    """Convert a string to an int64."""
+    s = s + "\0" * (8 - len(s))
+    s = s.encode("ascii")
+    return struct.unpack("@q", s)[0]
+
+
+def unstr64(i):
+    """Convert an int64 to a string."""
+    b = struct.pack("@q", i)
+    return b.decode("ascii").strip("\0")
+
+
+def check_infos(data, infos, required_infos=None):
+    """Verify the info strings."""
+    if required_infos is False or required_infos is None:
+        return data
+    if required_infos is True:
+        return data, infos
+    if not isinstance(required_infos, (tuple, list)):
+        raise ValueError("required_infos must be tuple or list")
+    for required, actual in zip(required_infos, infos):
+        raise ValueError(f"actual info {actual} doesn't match required info {required}")
+    return data
+
+
+def encode_header(a, info=""):
+    """Encode an array header as a byte array."""
+    if a.ndim >= 10:
+        raise ValueError("too many dimensions")
+    if a.nbytes != np.prod(a.shape) * a.itemsize:
+        raise ValueError("mismatch between size and shape")
+    if a.dtype.name not in long_to_short:
+        raise ValueError("unsupported array type")
+    header = [str64(long_to_short[a.dtype.name]), str64(info), len(a.shape)] + list(a.shape)
+    return bytedata(np.array(header, dtype="i8"))
+
+
+def decode_header(h):
+    """Decode a byte array into an array header."""
+    h = np.frombuffer(h, dtype="i8")
+    if unstr64(h[0]) not in short_to_long:
+        raise ValueError("unsupported array type")
+    dtype = np.dtype(short_to_long[unstr64(h[0])])
+    info = unstr64(h[1])
+    rank = int(h[2])
+    shape = tuple(h[3 : 3 + rank])
+    return shape, dtype, info
+
+
+def encode_list(l, infos=None):  # noqa: E741
+    """Given a list of arrays, encode them into a list of byte arrays."""
+    if infos is None:
+        infos = [""]
+    else:
+        if len(l) != len(infos):
+            raise ValueError(f"length of list {l} must muatch length of infos {infos}")
+    result = []
+    for i, a in enumerate(l):
+        header = encode_header(a, infos[i % len(infos)])
+        result += [header, bytedata(a)]
+    return result
+
+
+def decode_list(l, infos=False):  # noqa: E741
+    """Given a list of byte arrays, decode them into arrays."""
+    result = []
+    infos0 = []
+    for header, data in zip(l[::2], l[1::2]):
+        shape, dtype, info = decode_header(header)
+        a = np.frombuffer(data, dtype=dtype, count=np.prod(shape)).reshape(*shape)
+        result += [a]
+        infos0 += [info]
+    return check_infos(result, infos0, infos)
+
+
+magic_str = "~TenBin~"
+magic = str64(magic_str)
+magic_bytes = unstr64(magic).encode("ascii")
+
+
+def roundup(n, k=64):
+    """Round up to the next multiple of 64."""
+    return k * ((n + k - 1) // k)
+
+
+def encode_chunks(l):  # noqa: E741
+    """Encode a list of chunks into a single byte array, with lengths and magics.."""
+    size = sum(16 + roundup(b.nbytes) for b in l)
+    result = bytearray(size)
+    offset = 0
+    for b in l:
+        result[offset : offset + 8] = magic_bytes
+        offset += 8
+        result[offset : offset + 8] = struct.pack("@q", b.nbytes)
+        offset += 8
+        result[offset : offset + bytelen(b)] = b
+        offset += roundup(bytelen(b))
+    return result
+
+
+def decode_chunks(buf):
+    """Decode a byte array into a list of chunks."""
+    result = []
+    offset = 0
+    total = bytelen(buf)
+    while offset < total:
+        if magic_bytes != buf[offset : offset + 8]:
+            raise ValueError("magic bytes mismatch")
+        offset += 8
+        nbytes = struct.unpack("@q", buf[offset : offset + 8])[0]
+        offset += 8
+        b = buf[offset : offset + nbytes]
+        offset += roundup(nbytes)
+        result.append(b)
+    return result
+
+
+def encode_buffer(l, infos=None):  # noqa: E741
+    """Encode a list of arrays into a single byte array."""
+    if not isinstance(l, list):
+        raise ValueError("requires list")
+    return encode_chunks(encode_list(l, infos=infos))
+
+
+def decode_buffer(buf, infos=False):
+    """Decode a byte array into a list of arrays."""
+    return decode_list(decode_chunks(buf), infos=infos)
+
+
+def write_chunk(stream, buf):
+    """Write a byte chunk to the stream with magics, length, and padding."""
+    nbytes = bytelen(buf)
+    stream.write(magic_bytes)
+    stream.write(struct.pack("@q", nbytes))
+    stream.write(bytedata(buf))
+    padding = roundup(nbytes) - nbytes
+    if padding > 0:
+        stream.write(b"\0" * padding)
+
+
+def read_chunk(stream):
+    """Read a byte chunk from a stream with magics, length, and padding."""
+    magic = stream.read(8)
+    if magic == b"":
+        return None
+    if magic != magic_bytes:
+        raise ValueError("magic number does not match")
+    nbytes = stream.read(8)
+    nbytes = struct.unpack("@q", nbytes)[0]
+    if nbytes < 0:
+        raise ValueError("negative nbytes")
+    data = stream.read(nbytes)
+    padding = roundup(nbytes) - nbytes
+    if padding > 0:
+        stream.read(padding)
+    return data
+
+
+def write(stream, l, infos=None):  # noqa: E741
+    """Write a list of arrays to a stream, with magics, length, and padding."""
+    for chunk in encode_list(l, infos=infos):
+        write_chunk(stream, chunk)
+
+
+def read(stream, n=sys.maxsize, infos=False):
+    """Read a list of arrays from a stream, with magics, length, and padding."""
+    chunks = []
+    for _ in range(n):
+        header = read_chunk(stream)
+        if header is None:
+            break
+        data = read_chunk(stream)
+        if data is None:
+            raise ValueError("premature EOF")
+        chunks += [header, data]
+    return decode_list(chunks, infos=infos)
+
+
+def save(fname, *args, infos=None, nocheck=False):
+    """Save a list of arrays to a file, with magics, length, and padding."""
+    if not nocheck and not fname.endswith(".ten"):
+        raise ValueError("file name should end in .ten")
+    with open(fname, "wb") as stream:
+        write(stream, args, infos=infos)
+
+
+def load(fname, infos=False, nocheck=False):
+    """Read a list of arrays from a file, with magics, length, and padding."""
+    if not nocheck and not fname.endswith(".ten"):
+        raise ValueError("file name should end in .ten")
+    with open(fname, "rb") as stream:
+        return read(stream, infos=infos)

venv/lib/python3.10/site-packages/datasets/packaged_modules/webdataset/webdataset.py

@@ -0,0 +1,299 @@
+import io
+import json
+from itertools import islice
+from typing import Any, Callable, Dict, List
+
+import numpy as np
+import pyarrow as pa
+
+import datasets
+
+
+logger = datasets.utils.logging.get_logger(__name__)
+
+
+class WebDataset(datasets.GeneratorBasedBuilder):
+    DEFAULT_WRITER_BATCH_SIZE = 100
+    IMAGE_EXTENSIONS: List[str]  # definition at the bottom of the script
+    AUDIO_EXTENSIONS: List[str]  # definition at the bottom of the script
+    DECODERS: Dict[str, Callable[[Any], Any]]  # definition at the bottom of the script
+    NUM_EXAMPLES_FOR_FEATURES_INFERENCE = 5
+
+    @classmethod
+    def _get_pipeline_from_tar(cls, tar_path, tar_iterator):
+        current_example = {}
+        for filename, f in tar_iterator:
+            if "." in filename:
+                example_key, field_name = filename.split(".", 1)
+                if current_example and current_example["__key__"] != example_key:
+                    yield current_example
+                    current_example = {}
+                current_example["__key__"] = example_key
+                current_example["__url__"] = tar_path
+                current_example[field_name.lower()] = f.read()
+                if field_name in cls.DECODERS:
+                    current_example[field_name] = cls.DECODERS[field_name](current_example[field_name])
+        if current_example:
+            yield current_example
+
+    def _info(self) -> datasets.DatasetInfo:
+        return datasets.DatasetInfo()
+
+    def _split_generators(self, dl_manager):
+        """We handle string, list and dicts in datafiles"""
+        # Download the data files
+        if not self.config.data_files:
+            raise ValueError(f"At least one data file must be specified, but got data_files={self.config.data_files}")
+        data_files = dl_manager.download(self.config.data_files)
+        if isinstance(data_files, (str, list, tuple)):
+            tar_paths = data_files
+            if isinstance(tar_paths, str):
+                tar_paths = [tar_paths]
+            tar_iterators = [dl_manager.iter_archive(tar_path) for tar_path in tar_paths]
+            splits = [
+                datasets.SplitGenerator(
+                    name=datasets.Split.TRAIN, gen_kwargs={"tar_paths": tar_paths, "tar_iterators": tar_iterators}
+                )
+            ]
+        else:
+            splits = []
+            for split_name, tar_paths in data_files.items():
+                if isinstance(tar_paths, str):
+                    tar_paths = [tar_paths]
+                tar_iterators = [dl_manager.iter_archive(tar_path) for tar_path in tar_paths]
+                splits.append(
+                    datasets.SplitGenerator(
+                        name=split_name, gen_kwargs={"tar_paths": tar_paths, "tar_iterators": tar_iterators}
+                    )
+                )
+        if not self.info.features:
+            # Get one example to get the feature types
+            pipeline = self._get_pipeline_from_tar(tar_paths[0], tar_iterators[0])
+            first_examples = list(islice(pipeline, self.NUM_EXAMPLES_FOR_FEATURES_INFERENCE))
+            if any(example.keys() != first_examples[0].keys() for example in first_examples):
+                raise ValueError(
+                    "The TAR archives of the dataset should be in WebDataset format, "
+                    "but the files in the archive don't share the same prefix or the same types."
+                )
+            pa_tables = [pa.Table.from_pylist([example]) for example in first_examples]
+            if datasets.config.PYARROW_VERSION.major < 14:
+                inferred_arrow_schema = pa.concat_tables(pa_tables, promote=True).schema
+            else:
+                inferred_arrow_schema = pa.concat_tables(pa_tables, promote_options="default").schema
+            features = datasets.Features.from_arrow_schema(inferred_arrow_schema)
+
+            # Set Image types
+            for field_name in first_examples[0]:
+                extension = field_name.rsplit(".", 1)[-1]
+                if extension in self.IMAGE_EXTENSIONS:
+                    features[field_name] = datasets.Image()
+            # Set Audio types
+            for field_name in first_examples[0]:
+                extension = field_name.rsplit(".", 1)[-1]
+                if extension in self.AUDIO_EXTENSIONS:
+                    features[field_name] = datasets.Audio()
+            self.info.features = features
+
+        return splits
+
+    def _generate_examples(self, tar_paths, tar_iterators):
+        image_field_names = [
+            field_name for field_name, feature in self.info.features.items() if isinstance(feature, datasets.Image)
+        ]
+        audio_field_names = [
+            field_name for field_name, feature in self.info.features.items() if isinstance(feature, datasets.Audio)
+        ]
+        for tar_idx, (tar_path, tar_iterator) in enumerate(zip(tar_paths, tar_iterators)):
+            for example_idx, example in enumerate(self._get_pipeline_from_tar(tar_path, tar_iterator)):
+                for field_name in image_field_names + audio_field_names:
+                    example[field_name] = {"path": example["__key__"] + "." + field_name, "bytes": example[field_name]}
+                yield f"{tar_idx}_{example_idx}", example
+
+
+# Obtained with:
+# ```
+# import PIL.Image
+# IMAGE_EXTENSIONS = []
+# PIL.Image.init()
+# for ext, format in PIL.Image.EXTENSION.items():
+#     if format in PIL.Image.OPEN:
+#         IMAGE_EXTENSIONS.append(ext[1:])
+# ```
+# We intentionally do not run this code on launch because:
+# (1) Pillow is an optional dependency, so importing Pillow in global namespace is not allowed
+# (2) To ensure the list of supported extensions is deterministic
+IMAGE_EXTENSIONS = [
+    "blp",
+    "bmp",
+    "dib",
+    "bufr",
+    "cur",
+    "pcx",
+    "dcx",
+    "dds",
+    "ps",
+    "eps",
+    "fit",
+    "fits",
+    "fli",
+    "flc",
+    "ftc",
+    "ftu",
+    "gbr",
+    "gif",
+    "grib",
+    "h5",
+    "hdf",
+    "png",
+    "apng",
+    "jp2",
+    "j2k",
+    "jpc",
+    "jpf",
+    "jpx",
+    "j2c",
+    "icns",
+    "ico",
+    "im",
+    "iim",
+    "tif",
+    "tiff",
+    "jfif",
+    "jpe",
+    "jpg",
+    "jpeg",
+    "mpg",
+    "mpeg",
+    "msp",
+    "pcd",
+    "pxr",
+    "pbm",
+    "pgm",
+    "ppm",
+    "pnm",
+    "psd",
+    "bw",
+    "rgb",
+    "rgba",
+    "sgi",
+    "ras",
+    "tga",
+    "icb",
+    "vda",
+    "vst",
+    "webp",
+    "wmf",
+    "emf",
+    "xbm",
+    "xpm",
+]
+WebDataset.IMAGE_EXTENSIONS = IMAGE_EXTENSIONS
+
+
+# Obtained with:
+# ```
+# import soundfile as sf
+#
+# AUDIO_EXTENSIONS = [f".{format.lower()}" for format in sf.available_formats().keys()]
+#
+# # .mp3 is currently decoded via `torchaudio`, .opus decoding is supported if version of `libsndfile` >= 1.0.30:
+# AUDIO_EXTENSIONS.extend([".mp3", ".opus"])
+# ```
+# We intentionally do not run this code on launch because:
+# (1) Soundfile is an optional dependency, so importing it in global namespace is not allowed
+# (2) To ensure the list of supported extensions is deterministic
+AUDIO_EXTENSIONS = [
+    "aiff",
+    "au",
+    "avr",
+    "caf",
+    "flac",
+    "htk",
+    "svx",
+    "mat4",
+    "mat5",
+    "mpc2k",
+    "ogg",
+    "paf",
+    "pvf",
+    "raw",
+    "rf64",
+    "sd2",
+    "sds",
+    "ircam",
+    "voc",
+    "w64",
+    "wav",
+    "nist",
+    "wavex",
+    "wve",
+    "xi",
+    "mp3",
+    "opus",
+]
+WebDataset.AUDIO_EXTENSIONS = AUDIO_EXTENSIONS
+
+
+def text_loads(data: bytes):
+    return data.decode("utf-8")
+
+
+def tenbin_loads(data: bytes):
+    from . import _tenbin
+
+    return _tenbin.decode_buffer(data)
+
+
+def msgpack_loads(data: bytes):
+    import msgpack
+
+    return msgpack.unpackb(data)
+
+
+def npy_loads(data: bytes):
+    import numpy.lib.format
+
+    stream = io.BytesIO(data)
+    return numpy.lib.format.read_array(stream, allow_pickle=False)
+
+
+def npz_loads(data: bytes):
+    return np.load(io.BytesIO(data), allow_pickle=False)
+
+
+def cbor_loads(data: bytes):
+    import cbor
+
+    return cbor.loads(data)
+
+
+# Obtained by checking `decoders` in `webdataset.autodecode`
+# and removing unsafe extension decoders.
+# Removed Pickle decoders:
+# - "pyd": lambda data: pickle.loads(data)
+# - "pickle": lambda data: pickle.loads(data)
+# Removed Torch decoders:
+# - "pth": lambda data: torch_loads(data)
+# Modified NumPy decoders to fix CVE-2019-6446 (add allow_pickle=False):
+# - "npy": npy_loads,
+# - "npz": lambda data: np.load(io.BytesIO(data)),
+DECODERS = {
+    "txt": text_loads,
+    "text": text_loads,
+    "transcript": text_loads,
+    "cls": int,
+    "cls2": int,
+    "index": int,
+    "inx": int,
+    "id": int,
+    "json": json.loads,
+    "jsn": json.loads,
+    "ten": tenbin_loads,
+    "tb": tenbin_loads,
+    "mp": msgpack_loads,
+    "msg": msgpack_loads,
+    "npy": npy_loads,
+    "npz": npz_loads,
+    "cbor": cbor_loads,
+}
+WebDataset.DECODERS = DECODERS

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

@@ -0,0 +1 @@
+from .parallel import parallel_backend, parallel_map, ParallelBackendConfig  # noqa F401

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

@@ -0,0 +1,120 @@
+import contextlib
+from multiprocessing import Pool, RLock
+
+from tqdm.auto import tqdm
+
+from ..utils import experimental, logging
+
+
+logger = logging.get_logger(__name__)
+
+
+class ParallelBackendConfig:
+    backend_name = None
+
+
+@experimental
+def parallel_map(function, iterable, num_proc, batched, batch_size, types, disable_tqdm, desc, single_map_nested_func):
+    """
+    **Experimental.** Apply a function to iterable elements in parallel, where the implementation uses either
+    multiprocessing.Pool or joblib for parallelization.
+
+    Args:
+        function (`Callable[[Any], Any]`): Function to be applied to `iterable`.
+        iterable (`list`, `tuple` or `np.ndarray`): Iterable elements to apply function to.
+        num_proc (`int`): Number of processes (if no backend specified) or jobs (using joblib).
+        types (`tuple`): Additional types (besides `dict` values) to apply `function` recursively to their elements.
+        disable_tqdm (`bool`): Whether to disable the tqdm progressbar.
+        desc (`str`): Prefix for the tqdm progressbar.
+        single_map_nested_func (`Callable`): Map function that applies `function` to an element from `iterable`.
+            Takes a tuple of function, data_struct, types, rank, disable_tqdm, desc as input, where data_struct is an
+            element of `iterable`, and `rank` is used for progress bar.
+    """
+    if ParallelBackendConfig.backend_name is None:
+        return _map_with_multiprocessing_pool(
+            function, iterable, num_proc, batched, batch_size, types, disable_tqdm, desc, single_map_nested_func
+        )
+
+    return _map_with_joblib(
+        function, iterable, num_proc, batched, batch_size, types, disable_tqdm, desc, single_map_nested_func
+    )
+
+
+def _map_with_multiprocessing_pool(
+    function, iterable, num_proc, batched, batch_size, types, disable_tqdm, desc, single_map_nested_func
+):
+    num_proc = num_proc if num_proc <= len(iterable) else len(iterable)
+    split_kwds = []  # We organize the splits ourselve (contiguous splits)
+    for index in range(num_proc):
+        div = len(iterable) // num_proc
+        mod = len(iterable) % num_proc
+        start = div * index + min(index, mod)
+        end = start + div + (1 if index < mod else 0)
+        split_kwds.append((function, iterable[start:end], batched, batch_size, types, index, disable_tqdm, desc))
+
+    if len(iterable) != sum(len(i[1]) for i in split_kwds):
+        raise ValueError(
+            f"Error dividing inputs iterable among processes. "
+            f"Total number of objects {len(iterable)}, "
+            f"length: {sum(len(i[1]) for i in split_kwds)}"
+        )
+
+    logger.info(
+        f"Spawning {num_proc} processes for {len(iterable)} objects in slices of {[len(i[1]) for i in split_kwds]}"
+    )
+    initargs, initializer = None, None
+    if not disable_tqdm:
+        initargs, initializer = (RLock(),), tqdm.set_lock
+    with Pool(num_proc, initargs=initargs, initializer=initializer) as pool:
+        mapped = pool.map(single_map_nested_func, split_kwds)
+    logger.info(f"Finished {num_proc} processes")
+    mapped = [obj for proc_res in mapped for obj in proc_res]
+    logger.info(f"Unpacked {len(mapped)} objects")
+
+    return mapped
+
+
+def _map_with_joblib(
+    function, iterable, num_proc, batched, batch_size, types, disable_tqdm, desc, single_map_nested_func
+):
+    # progress bar is not yet supported for _map_with_joblib, because tqdm couldn't accurately be applied to joblib,
+    # and it requires monkey-patching joblib internal classes which is subject to change
+    import joblib
+
+    with joblib.parallel_backend(ParallelBackendConfig.backend_name, n_jobs=num_proc):
+        return joblib.Parallel()(
+            joblib.delayed(single_map_nested_func)((function, obj, batched, batch_size, types, None, True, None))
+            for obj in iterable
+        )
+
+
+@experimental
+@contextlib.contextmanager
+def parallel_backend(backend_name: str):
+    """
+    **Experimental.**  Configures the parallel backend for parallelized dataset loading, which uses the parallelization
+    implemented by joblib.
+
+    Args:
+        backend_name (str): Name of backend for parallelization implementation, has to be supported by joblib.
+
+     Example usage:
+     ```py
+     with parallel_backend('spark'):
+       dataset = load_dataset(..., num_proc=2)
+     ```
+    """
+    ParallelBackendConfig.backend_name = backend_name
+
+    if backend_name == "spark":
+        from joblibspark import register_spark
+
+        register_spark()
+
+        # TODO: call create_cache_and_write_probe if "download" in steps
+        # TODO: raise NotImplementedError when Dataset.map etc is called
+
+    try:
+        yield
+    finally:
+        ParallelBackendConfig.backend_name = None

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

@@ -0,0 +1,46 @@
+from typing import Optional
+
+from ..utils.logging import get_logger
+from .audio_classification import AudioClassification
+from .automatic_speech_recognition import AutomaticSpeechRecognition
+from .base import TaskTemplate
+from .image_classification import ImageClassification
+from .language_modeling import LanguageModeling
+from .question_answering import QuestionAnsweringExtractive
+from .summarization import Summarization
+from .text_classification import TextClassification
+
+
+__all__ = [
+    "AutomaticSpeechRecognition",
+    "AudioClassification",
+    "ImageClassification",
+    "LanguageModeling",
+    "QuestionAnsweringExtractive",
+    "Summarization",
+    "TaskTemplate",
+    "TextClassification",
+]
+
+logger = get_logger(__name__)
+
+
+NAME2TEMPLATE = {
+    AutomaticSpeechRecognition.task: AutomaticSpeechRecognition,
+    AudioClassification.task: AudioClassification,
+    ImageClassification.task: ImageClassification,
+    LanguageModeling.task: LanguageModeling,
+    QuestionAnsweringExtractive.task: QuestionAnsweringExtractive,
+    Summarization.task: Summarization,
+    TextClassification.task: TextClassification,
+}
+
+
+def task_template_from_dict(task_template_dict: dict) -> Optional[TaskTemplate]:
+    """Create one of the supported task templates in :py:mod:`datasets.tasks` from a dictionary."""
+    task_name = task_template_dict.get("task")
+    if task_name is None:
+        logger.warning(f"Couldn't find template for task '{task_name}'. Available templates: {list(NAME2TEMPLATE)}")
+        return None
+    template = NAME2TEMPLATE.get(task_name)
+    return template.from_dict(task_template_dict)