Add files using upload-large-folder tool

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

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

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

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

ckpts/universal/global_step20/zero/20.mlp.dense_h_to_4h_swiglu.weight/fp32.pt

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

ckpts/universal/global_step20/zero/3.mlp.dense_4h_to_h.weight/exp_avg_sq.pt

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

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

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

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

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

venv/lib/python3.10/site-packages/click-8.1.7.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

venv/lib/python3.10/site-packages/click-8.1.7.dist-info/LICENSE.rst

@@ -0,0 +1,28 @@
+Copyright 2014 Pallets
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+1.  Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+
+2.  Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+
+3.  Neither the name of the copyright holder nor the names of its
+    contributors may be used to endorse or promote products derived from
+    this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

venv/lib/python3.10/site-packages/click-8.1.7.dist-info/METADATA

@@ -0,0 +1,103 @@
+Metadata-Version: 2.1
+Name: click
+Version: 8.1.7
+Summary: Composable command line interface toolkit
+Home-page: https://palletsprojects.com/p/click/
+Maintainer: Pallets
+Maintainer-email: [email protected]
+License: BSD-3-Clause
+Project-URL: Donate, https://palletsprojects.com/donate
+Project-URL: Documentation, https://click.palletsprojects.com/
+Project-URL: Changes, https://click.palletsprojects.com/changes/
+Project-URL: Source Code, https://github.com/pallets/click/
+Project-URL: Issue Tracker, https://github.com/pallets/click/issues/
+Project-URL: Chat, https://discord.gg/pallets
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+License-File: LICENSE.rst
+Requires-Dist: colorama ; platform_system == "Windows"
+Requires-Dist: importlib-metadata ; python_version < "3.8"
+
+\$ click\_
+==========
+
+Click is a Python package for creating beautiful command line interfaces
+in a composable way with as little code as necessary. It's the "Command
+Line Interface Creation Kit". It's highly configurable but comes with
+sensible defaults out of the box.
+
+It aims to make the process of writing command line tools quick and fun
+while also preventing any frustration caused by the inability to
+implement an intended CLI API.
+
+Click in three points:
+
+-   Arbitrary nesting of commands
+-   Automatic help page generation
+-   Supports lazy loading of subcommands at runtime
+
+
+Installing
+----------
+
+Install and update using `pip`_:
+
+.. code-block:: text
+
+    $ pip install -U click
+
+.. _pip: https://pip.pypa.io/en/stable/getting-started/
+
+
+A Simple Example
+----------------
+
+.. code-block:: python
+
+    import click
+
+    @click.command()
+    @click.option("--count", default=1, help="Number of greetings.")
+    @click.option("--name", prompt="Your name", help="The person to greet.")
+    def hello(count, name):
+        """Simple program that greets NAME for a total of COUNT times."""
+        for _ in range(count):
+            click.echo(f"Hello, {name}!")
+
+    if __name__ == '__main__':
+        hello()
+
+.. code-block:: text
+
+    $ python hello.py --count=3
+    Your name: Click
+    Hello, Click!
+    Hello, Click!
+    Hello, Click!
+
+
+Donate
+------
+
+The Pallets organization develops and supports Click and other popular
+packages. In order to grow the community of contributors and users, and
+allow the maintainers to devote more time to the projects, `please
+donate today`_.
+
+.. _please donate today: https://palletsprojects.com/donate
+
+
+Links
+-----
+
+-   Documentation: https://click.palletsprojects.com/
+-   Changes: https://click.palletsprojects.com/changes/
+-   PyPI Releases: https://pypi.org/project/click/
+-   Source Code: https://github.com/pallets/click
+-   Issue Tracker: https://github.com/pallets/click/issues
+-   Chat: https://discord.gg/pallets

venv/lib/python3.10/site-packages/click-8.1.7.dist-info/RECORD

@@ -0,0 +1,39 @@
+click-8.1.7.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+click-8.1.7.dist-info/LICENSE.rst,sha256=morRBqOU6FO_4h9C9OctWSgZoigF2ZG18ydQKSkrZY0,1475
+click-8.1.7.dist-info/METADATA,sha256=qIMevCxGA9yEmJOM_4WHuUJCwWpsIEVbCPOhs45YPN4,3014
+click-8.1.7.dist-info/RECORD,,
+click-8.1.7.dist-info/WHEEL,sha256=5sUXSg9e4bi7lTLOHcm6QEYwO5TIF1TNbTSVFVjcJcc,92
+click-8.1.7.dist-info/top_level.txt,sha256=J1ZQogalYS4pphY_lPECoNMfw0HzTSrZglC4Yfwo4xA,6
+click/__init__.py,sha256=YDDbjm406dTOA0V8bTtdGnhN7zj5j-_dFRewZF_pLvw,3138
+click/__pycache__/__init__.cpython-310.pyc,,
+click/__pycache__/_compat.cpython-310.pyc,,
+click/__pycache__/_termui_impl.cpython-310.pyc,,
+click/__pycache__/_textwrap.cpython-310.pyc,,
+click/__pycache__/_winconsole.cpython-310.pyc,,
+click/__pycache__/core.cpython-310.pyc,,
+click/__pycache__/decorators.cpython-310.pyc,,
+click/__pycache__/exceptions.cpython-310.pyc,,
+click/__pycache__/formatting.cpython-310.pyc,,
+click/__pycache__/globals.cpython-310.pyc,,
+click/__pycache__/parser.cpython-310.pyc,,
+click/__pycache__/shell_completion.cpython-310.pyc,,
+click/__pycache__/termui.cpython-310.pyc,,
+click/__pycache__/testing.cpython-310.pyc,,
+click/__pycache__/types.cpython-310.pyc,,
+click/__pycache__/utils.cpython-310.pyc,,
+click/_compat.py,sha256=5318agQpbt4kroKsbqDOYpTSWzL_YCZVUQiTT04yXmc,18744
+click/_termui_impl.py,sha256=3dFYv4445Nw-rFvZOTBMBPYwB1bxnmNk9Du6Dm_oBSU,24069
+click/_textwrap.py,sha256=10fQ64OcBUMuK7mFvh8363_uoOxPlRItZBmKzRJDgoY,1353
+click/_winconsole.py,sha256=5ju3jQkcZD0W27WEMGqmEP4y_crUVzPCqsX_FYb7BO0,7860
+click/core.py,sha256=j6oEWtGgGna8JarD6WxhXmNnxLnfRjwXglbBc-8jr7U,114086
+click/decorators.py,sha256=-ZlbGYgV-oI8jr_oH4RpuL1PFS-5QmeuEAsLDAYgxtw,18719
+click/exceptions.py,sha256=fyROO-47HWFDjt2qupo7A3J32VlpM-ovJnfowu92K3s,9273
+click/formatting.py,sha256=Frf0-5W33-loyY_i9qrwXR8-STnW3m5gvyxLVUdyxyk,9706
+click/globals.py,sha256=TP-qM88STzc7f127h35TD_v920FgfOD2EwzqA0oE8XU,1961
+click/parser.py,sha256=LKyYQE9ZLj5KgIDXkrcTHQRXIggfoivX14_UVIn56YA,19067
+click/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+click/shell_completion.py,sha256=Ty3VM_ts0sQhj6u7eFTiLwHPoTgcXTGEAUg2OpLqYKw,18460
+click/termui.py,sha256=H7Q8FpmPelhJ2ovOhfCRhjMtCpNyjFXryAMLZODqsdc,28324
+click/testing.py,sha256=1Qd4kS5bucn1hsNIRryd0WtTMuCpkA93grkWxT8POsU,16084
+click/types.py,sha256=TZvz3hKvBztf-Hpa2enOmP4eznSPLzijjig5b_0XMxE,36391
+click/utils.py,sha256=1476UduUNY6UePGU4m18uzVHLt1sKM2PP3yWsQhbItM,20298

venv/lib/python3.10/site-packages/click-8.1.7.dist-info/WHEEL

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

venv/lib/python3.10/site-packages/click-8.1.7.dist-info/top_level.txt

@@ -0,0 +1 @@
+click

venv/lib/python3.10/site-packages/datasets/utils/download_manager.py

@@ -0,0 +1 @@
+# deprecated, please use datasets.download.download_manager

venv/lib/python3.10/site-packages/datasets/utils/experimental.py

@@ -0,0 +1,43 @@
+"""Contains utilities to flag a feature as "experimental" in datasets."""
+
+import warnings
+from functools import wraps
+from typing import Callable
+
+
+def experimental(fn: Callable) -> Callable:
+    """Decorator to flag a feature as experimental.
+
+    An experimental feature trigger a warning when used as it might be subject to breaking changes in the future.
+
+    Args:
+        fn (`Callable`):
+            The function to flag as experimental.
+
+    Returns:
+        `Callable`: The decorated function.
+
+    Example:
+
+    ```python
+    >>> from datasets.utils import experimental
+
+    >>> @experimental
+    ... def my_function():
+    ...     print("Hello world!")
+
+    >>> my_function()
+    UserWarning: 'my_function' is experimental and might be subject to breaking changes in the future.
+    Hello world!
+    ```
+    """
+
+    @wraps(fn)
+    def _inner_fn(*args, **kwargs):
+        warnings.warn(
+            (f"'{fn.__name__}' is experimental and might be subject to breaking changes in the future."),
+            UserWarning,
+        )
+        return fn(*args, **kwargs)
+
+    return _inner_fn

venv/lib/python3.10/site-packages/datasets/utils/extract.py

@@ -0,0 +1,351 @@
+import bz2
+import gzip
+import lzma
+import os
+import shutil
+import struct
+import tarfile
+import warnings
+import zipfile
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Dict, List, Optional, Type, Union
+
+from .. import config
+from ._filelock import FileLock
+from .logging import get_logger
+
+
+logger = get_logger(__name__)
+
+
+class ExtractManager:
+    def __init__(self, cache_dir: Optional[str] = None):
+        self.extract_dir = (
+            os.path.join(cache_dir, config.EXTRACTED_DATASETS_DIR) if cache_dir else config.EXTRACTED_DATASETS_PATH
+        )
+        self.extractor = Extractor
+
+    def _get_output_path(self, path: str) -> str:
+        from .file_utils import hash_url_to_filename
+
+        # Path where we extract compressed archives
+        # We extract in the cache dir, and get the extracted path name by hashing the original path"
+        abs_path = os.path.abspath(path)
+        return os.path.join(self.extract_dir, hash_url_to_filename(abs_path))
+
+    def _do_extract(self, output_path: str, force_extract: bool) -> bool:
+        return force_extract or (
+            not os.path.isfile(output_path) and not (os.path.isdir(output_path) and os.listdir(output_path))
+        )
+
+    def extract(self, input_path: str, force_extract: bool = False) -> str:
+        extractor_format = self.extractor.infer_extractor_format(input_path)
+        if not extractor_format:
+            return input_path
+        output_path = self._get_output_path(input_path)
+        if self._do_extract(output_path, force_extract):
+            self.extractor.extract(input_path, output_path, extractor_format)
+        return output_path
+
+
+class BaseExtractor(ABC):
+    @classmethod
+    @abstractmethod
+    def is_extractable(cls, path: Union[Path, str], **kwargs) -> bool: ...
+
+    @staticmethod
+    @abstractmethod
+    def extract(input_path: Union[Path, str], output_path: Union[Path, str]) -> None: ...
+
+
+class MagicNumberBaseExtractor(BaseExtractor, ABC):
+    magic_numbers: List[bytes] = []
+
+    @staticmethod
+    def read_magic_number(path: Union[Path, str], magic_number_length: int):
+        with open(path, "rb") as f:
+            return f.read(magic_number_length)
+
+    @classmethod
+    def is_extractable(cls, path: Union[Path, str], magic_number: bytes = b"") -> bool:
+        if not magic_number:
+            magic_number_length = max(len(cls_magic_number) for cls_magic_number in cls.magic_numbers)
+            try:
+                magic_number = cls.read_magic_number(path, magic_number_length)
+            except OSError:
+                return False
+        return any(magic_number.startswith(cls_magic_number) for cls_magic_number in cls.magic_numbers)
+
+
+class TarExtractor(BaseExtractor):
+    @classmethod
+    def is_extractable(cls, path: Union[Path, str], **kwargs) -> bool:
+        return tarfile.is_tarfile(path)
+
+    @staticmethod
+    def safemembers(members, output_path):
+        """
+        Fix for CVE-2007-4559
+        Desc:
+            Directory traversal vulnerability in the (1) extract and (2) extractall functions in the tarfile
+            module in Python allows user-assisted remote attackers to overwrite arbitrary files via a .. (dot dot)
+            sequence in filenames in a TAR archive, a related issue to CVE-2001-1267.
+        See: https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2007-4559
+        From: https://stackoverflow.com/a/10077309
+        """
+
+        def resolved(path: str) -> str:
+            return os.path.realpath(os.path.abspath(path))
+
+        def badpath(path: str, base: str) -> bool:
+            # joinpath will ignore base if path is absolute
+            return not resolved(os.path.join(base, path)).startswith(base)
+
+        def badlink(info, base: str) -> bool:
+            # Links are interpreted relative to the directory containing the link
+            tip = resolved(os.path.join(base, os.path.dirname(info.name)))
+            return badpath(info.linkname, base=tip)
+
+        base = resolved(output_path)
+
+        for finfo in members:
+            if badpath(finfo.name, base):
+                logger.error(f"Extraction of {finfo.name} is blocked (illegal path)")
+            elif finfo.issym() and badlink(finfo, base):
+                logger.error(f"Extraction of {finfo.name} is blocked: Symlink to {finfo.linkname}")
+            elif finfo.islnk() and badlink(finfo, base):
+                logger.error(f"Extraction of {finfo.name} is blocked: Hard link to {finfo.linkname}")
+            else:
+                yield finfo
+
+    @staticmethod
+    def extract(input_path: Union[Path, str], output_path: Union[Path, str]) -> None:
+        os.makedirs(output_path, exist_ok=True)
+        tar_file = tarfile.open(input_path)
+        tar_file.extractall(output_path, members=TarExtractor.safemembers(tar_file, output_path))
+        tar_file.close()
+
+
+class GzipExtractor(MagicNumberBaseExtractor):
+    magic_numbers = [b"\x1f\x8b"]
+
+    @staticmethod
+    def extract(input_path: Union[Path, str], output_path: Union[Path, str]) -> None:
+        with gzip.open(input_path, "rb") as gzip_file:
+            with open(output_path, "wb") as extracted_file:
+                shutil.copyfileobj(gzip_file, extracted_file)
+
+
+class ZipExtractor(MagicNumberBaseExtractor):
+    magic_numbers = [
+        b"PK\x03\x04",
+        b"PK\x05\x06",  # empty archive
+        b"PK\x07\x08",  # spanned archive
+    ]
+
+    @classmethod
+    def is_extractable(cls, path: Union[Path, str], magic_number: bytes = b"") -> bool:
+        if super().is_extractable(path, magic_number=magic_number):
+            return True
+        try:
+            # Alternative version of zipfile.is_zipfile that has less false positives, but misses executable zip archives.
+            # From: https://github.com/python/cpython/pull/5053
+            from zipfile import (
+                _CD_SIGNATURE,
+                _ECD_DISK_NUMBER,
+                _ECD_DISK_START,
+                _ECD_ENTRIES_TOTAL,
+                _ECD_OFFSET,
+                _ECD_SIZE,
+                _EndRecData,
+                sizeCentralDir,
+                stringCentralDir,
+                structCentralDir,
+            )
+
+            with open(path, "rb") as fp:
+                endrec = _EndRecData(fp)
+                if endrec:
+                    if endrec[_ECD_ENTRIES_TOTAL] == 0 and endrec[_ECD_SIZE] == 0 and endrec[_ECD_OFFSET] == 0:
+                        return True  # Empty zipfiles are still zipfiles
+                    elif endrec[_ECD_DISK_NUMBER] == endrec[_ECD_DISK_START]:
+                        fp.seek(endrec[_ECD_OFFSET])  # Central directory is on the same disk
+                        if fp.tell() == endrec[_ECD_OFFSET] and endrec[_ECD_SIZE] >= sizeCentralDir:
+                            data = fp.read(sizeCentralDir)  # CD is where we expect it to be
+                            if len(data) == sizeCentralDir:
+                                centdir = struct.unpack(structCentralDir, data)  # CD is the right size
+                                if centdir[_CD_SIGNATURE] == stringCentralDir:
+                                    return True  # First central directory entry  has correct magic number
+            return False
+        except Exception:  # catch all errors in case future python versions change the zipfile internals
+            return False
+
+    @staticmethod
+    def extract(input_path: Union[Path, str], output_path: Union[Path, str]) -> None:
+        os.makedirs(output_path, exist_ok=True)
+        with zipfile.ZipFile(input_path, "r") as zip_file:
+            zip_file.extractall(output_path)
+            zip_file.close()
+
+
+class XzExtractor(MagicNumberBaseExtractor):
+    magic_numbers = [b"\xfd\x37\x7a\x58\x5a\x00"]
+
+    @staticmethod
+    def extract(input_path: Union[Path, str], output_path: Union[Path, str]) -> None:
+        with lzma.open(input_path) as compressed_file:
+            with open(output_path, "wb") as extracted_file:
+                shutil.copyfileobj(compressed_file, extracted_file)
+
+
+class RarExtractor(MagicNumberBaseExtractor):
+    magic_numbers = [b"Rar!\x1a\x07\x00", b"Rar!\x1a\x07\x01\x00"]  # RAR_ID  # RAR5_ID
+
+    @staticmethod
+    def extract(input_path: Union[Path, str], output_path: Union[Path, str]) -> None:
+        if not config.RARFILE_AVAILABLE:
+            raise ImportError("Please pip install rarfile")
+        import rarfile
+
+        os.makedirs(output_path, exist_ok=True)
+        rf = rarfile.RarFile(input_path)
+        rf.extractall(output_path)
+        rf.close()
+
+
+class ZstdExtractor(MagicNumberBaseExtractor):
+    magic_numbers = [b"\x28\xb5\x2f\xfd"]
+
+    @staticmethod
+    def extract(input_path: Union[Path, str], output_path: Union[Path, str]) -> None:
+        if not config.ZSTANDARD_AVAILABLE:
+            raise ImportError("Please pip install zstandard")
+        import zstandard as zstd
+
+        dctx = zstd.ZstdDecompressor()
+        with open(input_path, "rb") as ifh, open(output_path, "wb") as ofh:
+            dctx.copy_stream(ifh, ofh)
+
+
+class Bzip2Extractor(MagicNumberBaseExtractor):
+    magic_numbers = [b"\x42\x5a\x68"]
+
+    @staticmethod
+    def extract(input_path: Union[Path, str], output_path: Union[Path, str]) -> None:
+        with bz2.open(input_path, "rb") as compressed_file:
+            with open(output_path, "wb") as extracted_file:
+                shutil.copyfileobj(compressed_file, extracted_file)
+
+
+class SevenZipExtractor(MagicNumberBaseExtractor):
+    magic_numbers = [b"\x37\x7a\xbc\xaf\x27\x1c"]
+
+    @staticmethod
+    def extract(input_path: Union[Path, str], output_path: Union[Path, str]) -> None:
+        if not config.PY7ZR_AVAILABLE:
+            raise ImportError("Please pip install py7zr")
+        import py7zr
+
+        os.makedirs(output_path, exist_ok=True)
+        with py7zr.SevenZipFile(input_path, "r") as archive:
+            archive.extractall(output_path)
+
+
+class Lz4Extractor(MagicNumberBaseExtractor):
+    magic_numbers = [b"\x04\x22\x4d\x18"]
+
+    @staticmethod
+    def extract(input_path: Union[Path, str], output_path: Union[Path, str]) -> None:
+        if not config.LZ4_AVAILABLE:
+            raise ImportError("Please pip install lz4")
+        import lz4.frame
+
+        with lz4.frame.open(input_path, "rb") as compressed_file:
+            with open(output_path, "wb") as extracted_file:
+                shutil.copyfileobj(compressed_file, extracted_file)
+
+
+class Extractor:
+    #  Put zip file to the last, b/c it is possible wrongly detected as zip (I guess it means: as tar or gzip)
+    extractors: Dict[str, Type[BaseExtractor]] = {
+        "tar": TarExtractor,
+        "gzip": GzipExtractor,
+        "zip": ZipExtractor,
+        "xz": XzExtractor,
+        "rar": RarExtractor,
+        "zstd": ZstdExtractor,
+        "bz2": Bzip2Extractor,
+        "7z": SevenZipExtractor,  # <Added version="2.4.0"/>
+        "lz4": Lz4Extractor,  # <Added version="2.4.0"/>
+    }
+
+    @classmethod
+    def _get_magic_number_max_length(cls):
+        return max(
+            len(extractor_magic_number)
+            for extractor in cls.extractors.values()
+            if issubclass(extractor, MagicNumberBaseExtractor)
+            for extractor_magic_number in extractor.magic_numbers
+        )
+
+    @staticmethod
+    def _read_magic_number(path: Union[Path, str], magic_number_length: int):
+        try:
+            return MagicNumberBaseExtractor.read_magic_number(path, magic_number_length=magic_number_length)
+        except OSError:
+            return b""
+
+    @classmethod
+    def is_extractable(cls, path: Union[Path, str], return_extractor: bool = False) -> bool:
+        warnings.warn(
+            "Method 'is_extractable' was deprecated in version 2.4.0 and will be removed in 3.0.0. "
+            "Use 'infer_extractor_format' instead.",
+            category=FutureWarning,
+        )
+        extractor_format = cls.infer_extractor_format(path)
+        if extractor_format:
+            return True if not return_extractor else (True, cls.extractors[extractor_format])
+        return False if not return_extractor else (False, None)
+
+    @classmethod
+    def infer_extractor_format(cls, path: Union[Path, str]) -> Optional[str]:  # <Added version="2.4.0"/>
+        magic_number_max_length = cls._get_magic_number_max_length()
+        magic_number = cls._read_magic_number(path, magic_number_max_length)
+        for extractor_format, extractor in cls.extractors.items():
+            if extractor.is_extractable(path, magic_number=magic_number):
+                return extractor_format
+
+    @classmethod
+    def extract(
+        cls,
+        input_path: Union[Path, str],
+        output_path: Union[Path, str],
+        extractor_format: Optional[str] = None,  # <Added version="2.4.0"/>
+        extractor: Optional[BaseExtractor] = "deprecated",
+    ) -> None:
+        os.makedirs(os.path.dirname(output_path), exist_ok=True)
+        # Prevent parallel extractions
+        lock_path = str(Path(output_path).with_suffix(".lock"))
+        with FileLock(lock_path):
+            shutil.rmtree(output_path, ignore_errors=True)
+            if extractor_format or extractor != "deprecated":
+                if extractor != "deprecated" or not isinstance(extractor_format, str):  # passed as positional arg
+                    warnings.warn(
+                        "Parameter 'extractor' was deprecated in version 2.4.0 and will be removed in 3.0.0. "
+                        "Use 'extractor_format' instead.",
+                        category=FutureWarning,
+                    )
+                    extractor = extractor if extractor != "deprecated" else extractor_format
+                else:
+                    extractor = cls.extractors[extractor_format]
+                return extractor.extract(input_path, output_path)
+            else:
+                warnings.warn(
+                    "Parameter 'extractor_format' was made required in version 2.4.0 and not passing it will raise an "
+                    "exception in 3.0.0.",
+                    category=FutureWarning,
+                )
+                for extractor in cls.extractors.values():
+                    if extractor.is_extractable(input_path):
+                        return extractor.extract(input_path, output_path)

venv/lib/python3.10/site-packages/datasets/utils/file_utils.py

@@ -0,0 +1,1674 @@
+"""
+Utilities for working with the local dataset cache.
+This file is adapted from the AllenNLP library at https://github.com/allenai/allennlp
+Copyright by the AllenNLP authors.
+"""
+
+import copy
+import glob
+import io
+import json
+import multiprocessing
+import os
+import posixpath
+import re
+import shutil
+import sys
+import tarfile
+import time
+import urllib
+import warnings
+import xml.dom.minidom
+import zipfile
+from asyncio import TimeoutError
+from contextlib import closing, contextmanager
+from functools import partial
+from io import BytesIO
+from itertools import chain
+from pathlib import Path, PurePosixPath
+from typing import Any, Callable, Dict, Generator, List, Optional, Tuple, TypeVar, Union
+from unittest.mock import patch
+from urllib.parse import urljoin, urlparse
+from xml.etree import ElementTree as ET
+
+import fsspec
+import huggingface_hub
+import requests
+from aiohttp.client_exceptions import ClientError
+from fsspec.core import strip_protocol, url_to_fs
+from fsspec.utils import can_be_local
+from huggingface_hub.utils import EntryNotFoundError, insecure_hashlib
+from packaging import version
+
+from .. import __version__, config
+from ..download.download_config import DownloadConfig
+from ..filesystems import COMPRESSION_FILESYSTEMS
+from . import _tqdm, logging
+from . import tqdm as hf_tqdm
+from ._filelock import FileLock
+from .extract import ExtractManager
+from .track import TrackedIterable
+
+
+logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
+
+INCOMPLETE_SUFFIX = ".incomplete"
+
+T = TypeVar("T", str, Path)
+
+
+def init_hf_modules(hf_modules_cache: Optional[Union[Path, str]] = None) -> str:
+    """
+    Add hf_modules_cache to the python path.
+    By default hf_modules_cache='~/.cache/huggingface/modules'.
+    It can also be set with the environment variable HF_MODULES_CACHE.
+    This is used to add modules such as `datasets_modules`
+    """
+    hf_modules_cache = hf_modules_cache if hf_modules_cache is not None else config.HF_MODULES_CACHE
+    hf_modules_cache = str(hf_modules_cache)
+    if hf_modules_cache not in sys.path:
+        sys.path.append(hf_modules_cache)
+
+        os.makedirs(hf_modules_cache, exist_ok=True)
+        if not os.path.exists(os.path.join(hf_modules_cache, "__init__.py")):
+            with open(os.path.join(hf_modules_cache, "__init__.py"), "w"):
+                pass
+    return hf_modules_cache
+
+
+def is_remote_url(url_or_filename: str) -> bool:
+    return urlparse(url_or_filename).scheme != "" and not os.path.ismount(urlparse(url_or_filename).scheme + ":/")
+
+
+def is_local_path(url_or_filename: str) -> bool:
+    # On unix the scheme of a local path is empty (for both absolute and relative),
+    # while on windows the scheme is the drive name (ex: "c") for absolute paths.
+    # for details on the windows behavior, see https://bugs.python.org/issue42215
+    return urlparse(url_or_filename).scheme == "" or os.path.ismount(urlparse(url_or_filename).scheme + ":/")
+
+
+def is_relative_path(url_or_filename: str) -> bool:
+    return urlparse(url_or_filename).scheme == "" and not os.path.isabs(url_or_filename)
+
+
+def relative_to_absolute_path(path: T) -> T:
+    """Convert relative path to absolute path."""
+    abs_path_str = os.path.abspath(os.path.expanduser(os.path.expandvars(str(path))))
+    return Path(abs_path_str) if isinstance(path, Path) else abs_path_str
+
+
+def hf_bucket_url(identifier: str, filename: str, use_cdn=False, dataset=True) -> str:
+    if dataset:
+        endpoint = config.CLOUDFRONT_DATASETS_DISTRIB_PREFIX if use_cdn else config.S3_DATASETS_BUCKET_PREFIX
+    else:
+        endpoint = config.CLOUDFRONT_METRICS_DISTRIB_PREFIX if use_cdn else config.S3_METRICS_BUCKET_PREFIX
+    return "/".join((endpoint, identifier, filename))
+
+
+def head_hf_s3(
+    identifier: str, filename: str, use_cdn=False, dataset=True, max_retries=0
+) -> Union[requests.Response, Exception]:
+    return http_head(
+        hf_bucket_url(identifier=identifier, filename=filename, use_cdn=use_cdn, dataset=dataset),
+        max_retries=max_retries,
+    )
+
+
+def hf_github_url(path: str, name: str, dataset=True, revision: Optional[str] = None) -> str:
+    default_revision = "main" if version.parse(__version__).is_devrelease else __version__
+    revision = revision or default_revision
+    if dataset:
+        return config.REPO_DATASETS_URL.format(revision=revision, path=path, name=name)
+    else:
+        return config.REPO_METRICS_URL.format(revision=revision, path=path, name=name)
+
+
+def url_or_path_join(base_name: str, *pathnames: str) -> str:
+    if is_remote_url(base_name):
+        return posixpath.join(base_name, *(str(pathname).replace(os.sep, "/").lstrip("/") for pathname in pathnames))
+    else:
+        return Path(base_name, *pathnames).as_posix()
+
+
+def url_or_path_parent(url_or_path: str) -> str:
+    if is_remote_url(url_or_path):
+        return url_or_path[: url_or_path.rindex("/")]
+    else:
+        return os.path.dirname(url_or_path)
+
+
+def hash_url_to_filename(url, etag=None):
+    """
+    Convert `url` into a hashed filename in a repeatable way.
+    If `etag` is specified, append its hash to the url's, delimited
+    by a period.
+    If the url ends with .h5 (Keras HDF5 weights) adds '.h5' to the name
+    so that TF 2.0 can identify it as a HDF5 file
+    (see https://github.com/tensorflow/tensorflow/blob/00fad90125b18b80fe054de1055770cfb8fe4ba3/tensorflow/python/keras/engine/network.py#L1380)
+    """
+    url_bytes = url.encode("utf-8")
+    url_hash = insecure_hashlib.sha256(url_bytes)
+    filename = url_hash.hexdigest()
+
+    if etag:
+        etag_bytes = etag.encode("utf-8")
+        etag_hash = insecure_hashlib.sha256(etag_bytes)
+        filename += "." + etag_hash.hexdigest()
+
+    if url.endswith(".py"):
+        filename += ".py"
+
+    return filename
+
+
+def cached_path(
+    url_or_filename,
+    download_config=None,
+    **download_kwargs,
+) -> str:
+    """
+    Given something that might be a URL (or might be a local path),
+    determine which. If it's a URL, download the file and cache it, and
+    return the path to the cached file. If it's already a local path,
+    make sure the file exists and then return the path.
+
+    Return:
+        Local path (string)
+
+    Raises:
+        FileNotFoundError: in case of non-recoverable file
+            (non-existent or no cache on disk)
+        ConnectionError: in case of unreachable url
+            and no cache on disk
+        ValueError: if it couldn't parse the url or filename correctly
+        requests.exceptions.ConnectionError: in case of internet connection issue
+    """
+    if download_config is None:
+        download_config = DownloadConfig(**download_kwargs)
+
+    cache_dir = download_config.cache_dir or config.DOWNLOADED_DATASETS_PATH
+    if isinstance(cache_dir, Path):
+        cache_dir = str(cache_dir)
+    if isinstance(url_or_filename, Path):
+        url_or_filename = str(url_or_filename)
+
+    # Convert fsspec URL in the format "file://local/path" to "local/path"
+    if can_be_local(url_or_filename):
+        url_or_filename = strip_protocol(url_or_filename)
+
+    if is_remote_url(url_or_filename):
+        # URL, so get it from the cache (downloading if necessary)
+        output_path = get_from_cache(
+            url_or_filename,
+            cache_dir=cache_dir,
+            force_download=download_config.force_download,
+            proxies=download_config.proxies,
+            resume_download=download_config.resume_download,
+            user_agent=download_config.user_agent,
+            local_files_only=download_config.local_files_only,
+            use_etag=download_config.use_etag,
+            max_retries=download_config.max_retries,
+            token=download_config.token,
+            ignore_url_params=download_config.ignore_url_params,
+            storage_options=download_config.storage_options,
+            download_desc=download_config.download_desc,
+            disable_tqdm=download_config.disable_tqdm,
+        )
+    elif os.path.exists(url_or_filename):
+        # File, and it exists.
+        output_path = url_or_filename
+    elif is_local_path(url_or_filename):
+        # File, but it doesn't exist.
+        raise FileNotFoundError(f"Local file {url_or_filename} doesn't exist")
+    else:
+        # Something unknown
+        raise ValueError(f"unable to parse {url_or_filename} as a URL or as a local path")
+
+    if output_path is None:
+        return output_path
+
+    if download_config.extract_compressed_file:
+        if download_config.extract_on_the_fly:
+            # Add a compression prefix to the compressed file so that it can be extracted
+            # as it's being read using xopen.
+            protocol = _get_extraction_protocol(output_path, download_config=download_config)
+            extension = _get_path_extension(url_or_filename.split("::")[0])
+            if (
+                protocol
+                and extension not in ["tgz", "tar"]
+                and not url_or_filename.split("::")[0].endswith((".tar.gz", ".tar.bz2", ".tar.xz"))
+            ):
+                output_path = relative_to_absolute_path(output_path)
+                if protocol in SINGLE_FILE_COMPRESSION_PROTOCOLS:
+                    # there is one single file which is the uncompressed file
+                    inner_file = os.path.basename(output_path)
+                    inner_file = inner_file[: inner_file.rindex(".")] if "." in inner_file else inner_file
+                    output_path = f"{protocol}://{inner_file}::{output_path}"
+                else:
+                    output_path = f"{protocol}://::{output_path}"
+                return output_path
+
+        # Eager extraction
+        output_path = ExtractManager(cache_dir=download_config.cache_dir).extract(
+            output_path, force_extract=download_config.force_extract
+        )
+    return relative_to_absolute_path(output_path)
+
+
+def get_datasets_user_agent(user_agent: Optional[Union[str, dict]] = None) -> str:
+    ua = f"datasets/{__version__}"
+    ua += f"; python/{config.PY_VERSION}"
+    ua += f"; huggingface_hub/{huggingface_hub.__version__}"
+    ua += f"; pyarrow/{config.PYARROW_VERSION}"
+    if config.TORCH_AVAILABLE:
+        ua += f"; torch/{config.TORCH_VERSION}"
+    if config.TF_AVAILABLE:
+        ua += f"; tensorflow/{config.TF_VERSION}"
+    if config.JAX_AVAILABLE:
+        ua += f"; jax/{config.JAX_VERSION}"
+    if config.BEAM_AVAILABLE:
+        ua += f"; apache_beam/{config.BEAM_VERSION}"
+    if isinstance(user_agent, dict):
+        ua += f"; {'; '.join(f'{k}/{v}' for k, v in user_agent.items())}"
+    elif isinstance(user_agent, str):
+        ua += "; " + user_agent
+    return ua
+
+
+def get_authentication_headers_for_url(
+    url: str, token: Optional[Union[str, bool]] = None, use_auth_token: Optional[Union[str, bool]] = "deprecated"
+) -> dict:
+    """Handle the HF authentication"""
+    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 url.startswith(config.HF_ENDPOINT):
+        return huggingface_hub.utils.build_hf_headers(
+            token=token, library_name="datasets", library_version=__version__
+        )
+    else:
+        return {}
+
+
+class OfflineModeIsEnabled(ConnectionError):
+    pass
+
+
+def _raise_if_offline_mode_is_enabled(msg: Optional[str] = None):
+    """Raise an OfflineModeIsEnabled error (subclass of ConnectionError) if HF_DATASETS_OFFLINE is True."""
+    if config.HF_DATASETS_OFFLINE:
+        raise OfflineModeIsEnabled(
+            "Offline mode is enabled." if msg is None else "Offline mode is enabled. " + str(msg)
+        )
+
+
+def _request_with_retry(
+    method: str,
+    url: str,
+    max_retries: int = 0,
+    base_wait_time: float = 0.5,
+    max_wait_time: float = 2,
+    timeout: float = 10.0,
+    **params,
+) -> requests.Response:
+    """Wrapper around requests to retry in case it fails with a ConnectTimeout, with exponential backoff.
+
+    Note that if the environment variable HF_DATASETS_OFFLINE is set to 1, then a OfflineModeIsEnabled error is raised.
+
+    Args:
+        method (str): HTTP method, such as 'GET' or 'HEAD'.
+        url (str): The URL of the resource to fetch.
+        max_retries (int): Maximum number of retries, defaults to 0 (no retries).
+        base_wait_time (float): Duration (in seconds) to wait before retrying the first time. Wait time between
+            retries then grows exponentially, capped by max_wait_time.
+        max_wait_time (float): Maximum amount of time between two retries, in seconds.
+        **params (additional keyword arguments): Params to pass to :obj:`requests.request`.
+    """
+    _raise_if_offline_mode_is_enabled(f"Tried to reach {url}")
+    tries, success = 0, False
+    while not success:
+        tries += 1
+        try:
+            response = requests.request(method=method.upper(), url=url, timeout=timeout, **params)
+            success = True
+        except (requests.exceptions.ConnectTimeout, requests.exceptions.ConnectionError) as err:
+            if tries > max_retries:
+                raise err
+            else:
+                logger.info(f"{method} request to {url} timed out, retrying... [{tries/max_retries}]")
+                sleep_time = min(max_wait_time, base_wait_time * 2 ** (tries - 1))  # Exponential backoff
+                time.sleep(sleep_time)
+    return response
+
+
+def fsspec_head(url, storage_options=None):
+    _raise_if_offline_mode_is_enabled(f"Tried to reach {url}")
+    fs, path = url_to_fs(url, **(storage_options or {}))
+    return fs.info(path)
+
+
+def stack_multiprocessing_download_progress_bars():
+    # Stack downloads progress bars automatically using HF_DATASETS_STACK_MULTIPROCESSING_DOWNLOAD_PROGRESS_BARS=1
+    # We use environment variables since the download may happen in a subprocess
+    return patch.dict(os.environ, {"HF_DATASETS_STACK_MULTIPROCESSING_DOWNLOAD_PROGRESS_BARS": "1"})
+
+
+class TqdmCallback(fsspec.callbacks.TqdmCallback):
+    def __init__(self, tqdm_kwargs=None, *args, **kwargs):
+        if config.FSSPEC_VERSION < version.parse("2024.2.0"):
+            super().__init__(tqdm_kwargs, *args, **kwargs)
+            self._tqdm = _tqdm  # replace tqdm module by datasets.utils.tqdm module
+        else:
+            kwargs["tqdm_cls"] = _tqdm.tqdm
+            super().__init__(tqdm_kwargs, *args, **kwargs)
+
+
+def fsspec_get(url, temp_file, storage_options=None, desc=None, disable_tqdm=False):
+    _raise_if_offline_mode_is_enabled(f"Tried to reach {url}")
+    fs, path = url_to_fs(url, **(storage_options or {}))
+    callback = TqdmCallback(
+        tqdm_kwargs={
+            "desc": desc or "Downloading",
+            "unit": "B",
+            "unit_scale": True,
+            "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,
+            "disable": disable_tqdm,
+        }
+    )
+    fs.get_file(path, temp_file.name, callback=callback)
+
+
+def ftp_head(url, timeout=10.0):
+    _raise_if_offline_mode_is_enabled(f"Tried to reach {url}")
+    try:
+        with closing(urllib.request.urlopen(url, timeout=timeout)) as r:
+            r.read(1)
+    except Exception:
+        return False
+    return True
+
+
+def ftp_get(url, temp_file, timeout=10.0):
+    _raise_if_offline_mode_is_enabled(f"Tried to reach {url}")
+    try:
+        logger.info(f"Getting through FTP {url} into {temp_file.name}")
+        with closing(urllib.request.urlopen(url, timeout=timeout)) as r:
+            shutil.copyfileobj(r, temp_file)
+    except urllib.error.URLError as e:
+        raise ConnectionError(e) from None
+
+
+def http_get(
+    url,
+    temp_file,
+    proxies=None,
+    resume_size=0,
+    headers=None,
+    cookies=None,
+    timeout=100.0,
+    max_retries=0,
+    desc=None,
+    disable_tqdm=False,
+) -> Optional[requests.Response]:
+    headers = dict(headers) if headers is not None else {}
+    headers["user-agent"] = get_datasets_user_agent(user_agent=headers.get("user-agent"))
+    if resume_size > 0:
+        headers["Range"] = f"bytes={resume_size:d}-"
+    response = _request_with_retry(
+        method="GET",
+        url=url,
+        stream=True,
+        proxies=proxies,
+        headers=headers,
+        cookies=cookies,
+        max_retries=max_retries,
+        timeout=timeout,
+    )
+    if temp_file is None:
+        return response
+    if response.status_code == 416:  # Range not satisfiable
+        return
+    content_length = response.headers.get("Content-Length")
+    total = resume_size + int(content_length) if content_length is not None else None
+    with hf_tqdm(
+        unit="B",
+        unit_scale=True,
+        total=total,
+        initial=resume_size,
+        desc=desc or "Downloading",
+        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,
+        disable=disable_tqdm,
+    ) as progress:
+        for chunk in response.iter_content(chunk_size=1024):
+            progress.update(len(chunk))
+            temp_file.write(chunk)
+
+
+def http_head(
+    url, proxies=None, headers=None, cookies=None, allow_redirects=True, timeout=10.0, max_retries=0
+) -> requests.Response:
+    headers = copy.deepcopy(headers) or {}
+    headers["user-agent"] = get_datasets_user_agent(user_agent=headers.get("user-agent"))
+    response = _request_with_retry(
+        method="HEAD",
+        url=url,
+        proxies=proxies,
+        headers=headers,
+        cookies=cookies,
+        allow_redirects=allow_redirects,
+        timeout=timeout,
+        max_retries=max_retries,
+    )
+    return response
+
+
+def request_etag(
+    url: str, token: Optional[Union[str, bool]] = None, use_auth_token: Optional[Union[str, bool]] = "deprecated"
+) -> Optional[str]:
+    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 urlparse(url).scheme not in ("http", "https"):
+        return None
+    headers = get_authentication_headers_for_url(url, token=token)
+    response = http_head(url, headers=headers, max_retries=3)
+    response.raise_for_status()
+    etag = response.headers.get("ETag") if response.ok else None
+    return etag
+
+
+def get_from_cache(
+    url,
+    cache_dir=None,
+    force_download=False,
+    proxies=None,
+    etag_timeout=100,
+    resume_download=False,
+    user_agent=None,
+    local_files_only=False,
+    use_etag=True,
+    max_retries=0,
+    token=None,
+    use_auth_token="deprecated",
+    ignore_url_params=False,
+    storage_options=None,
+    download_desc=None,
+    disable_tqdm=False,
+) -> str:
+    """
+    Given a URL, look for the corresponding file in the local cache.
+    If it's not there, download it. Then return the path to the cached file.
+
+    Return:
+        Local path (string)
+
+    Raises:
+        FileNotFoundError: in case of non-recoverable file
+            (non-existent or no cache on disk)
+        ConnectionError: in case of unreachable url
+            and no cache on disk
+    """
+    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 cache_dir is None:
+        cache_dir = config.HF_DATASETS_CACHE
+    if isinstance(cache_dir, Path):
+        cache_dir = str(cache_dir)
+
+    os.makedirs(cache_dir, exist_ok=True)
+
+    if ignore_url_params:
+        # strip all query parameters and #fragments from the URL
+        cached_url = urljoin(url, urlparse(url).path)
+    else:
+        cached_url = url  # additional parameters may be added to the given URL
+
+    connected = False
+    response = None
+    cookies = None
+    etag = None
+    head_error = None
+    scheme = None
+
+    # Try a first time to file the file on the local file system without eTag (None)
+    # if we don't ask for 'force_download' then we spare a request
+    filename = hash_url_to_filename(cached_url, etag=None)
+    cache_path = os.path.join(cache_dir, filename)
+
+    if os.path.exists(cache_path) and not force_download and not use_etag:
+        return cache_path
+
+    # Prepare headers for authentication
+    headers = get_authentication_headers_for_url(url, token=token)
+    if user_agent is not None:
+        headers["user-agent"] = user_agent
+
+    # We don't have the file locally or we need an eTag
+    if not local_files_only:
+        scheme = urlparse(url).scheme
+        if scheme == "ftp":
+            connected = ftp_head(url)
+        elif scheme not in ("http", "https"):
+            response = fsspec_head(url, storage_options=storage_options)
+            # s3fs uses "ETag", gcsfs uses "etag"
+            etag = (response.get("ETag", None) or response.get("etag", None)) if use_etag else None
+            connected = True
+        try:
+            response = http_head(
+                url,
+                allow_redirects=True,
+                proxies=proxies,
+                timeout=etag_timeout,
+                max_retries=max_retries,
+                headers=headers,
+            )
+            if response.status_code == 200:  # ok
+                etag = response.headers.get("ETag") if use_etag else None
+                for k, v in response.cookies.items():
+                    # In some edge cases, we need to get a confirmation token
+                    if k.startswith("download_warning") and "drive.google.com" in url:
+                        url += "&confirm=" + v
+                        cookies = response.cookies
+                connected = True
+                # Fix Google Drive URL to avoid Virus scan warning
+                if "drive.google.com" in url and "confirm=" not in url:
+                    url += "&confirm=t"
+            # In some edge cases, head request returns 400 but the connection is actually ok
+            elif (
+                (response.status_code == 400 and "firebasestorage.googleapis.com" in url)
+                or (response.status_code == 405 and "drive.google.com" in url)
+                or (
+                    response.status_code == 403
+                    and (
+                        re.match(r"^https?://github.com/.*?/.*?/releases/download/.*?/.*?$", url)
+                        or re.match(r"^https://.*?s3.*?amazonaws.com/.*?$", response.url)
+                    )
+                )
+                or (response.status_code == 403 and "ndownloader.figstatic.com" in url)
+            ):
+                connected = True
+                logger.info(f"Couldn't get ETag version for url {url}")
+            elif response.status_code == 401 and config.HF_ENDPOINT in url and token is None:
+                raise ConnectionError(
+                    f"Unauthorized for URL {url}. Please use the parameter `token=True` after logging in with `huggingface-cli login`"
+                )
+        except (OSError, requests.exceptions.Timeout) as e:
+            # not connected
+            head_error = e
+            pass
+
+    # connected == False = we don't have a connection, or url doesn't exist, or is otherwise inaccessible.
+    # try to get the last downloaded one
+    if not connected:
+        if os.path.exists(cache_path) and not force_download:
+            return cache_path
+        if local_files_only:
+            raise FileNotFoundError(
+                f"Cannot find the requested files in the cached path at {cache_path} and outgoing traffic has been"
+                " disabled. To enable file online look-ups, set 'local_files_only' to False."
+            )
+        elif response is not None and response.status_code == 404:
+            raise FileNotFoundError(f"Couldn't find file at {url}")
+        _raise_if_offline_mode_is_enabled(f"Tried to reach {url}")
+        if head_error is not None:
+            raise ConnectionError(f"Couldn't reach {url} ({repr(head_error)})")
+        elif response is not None:
+            raise ConnectionError(f"Couldn't reach {url} (error {response.status_code})")
+        else:
+            raise ConnectionError(f"Couldn't reach {url}")
+
+    # Try a second time
+    filename = hash_url_to_filename(cached_url, etag)
+    cache_path = os.path.join(cache_dir, filename)
+
+    if os.path.exists(cache_path) and not force_download:
+        return cache_path
+
+    # From now on, connected is True.
+    # Prevent parallel downloads of the same file with a lock.
+    lock_path = cache_path + ".lock"
+    with FileLock(lock_path):
+        # Retry in case previously locked processes just enter after the precedent process releases the lock
+        if os.path.exists(cache_path) and not force_download:
+            return cache_path
+
+        incomplete_path = cache_path + ".incomplete"
+
+        @contextmanager
+        def temp_file_manager(mode="w+b"):
+            with open(incomplete_path, mode) as f:
+                yield f
+
+        resume_size = 0
+        if resume_download:
+            temp_file_manager = partial(temp_file_manager, mode="a+b")
+            if os.path.exists(incomplete_path):
+                resume_size = os.stat(incomplete_path).st_size
+
+        # Download to temporary file, then copy to cache path once finished.
+        # Otherwise, you get corrupt cache entries if the download gets interrupted.
+        with temp_file_manager() as temp_file:
+            logger.info(f"{url} not found in cache or force_download set to True, downloading to {temp_file.name}")
+
+            # GET file object
+            if scheme == "ftp":
+                ftp_get(url, temp_file)
+            elif scheme not in ("http", "https"):
+                fsspec_get(
+                    url, temp_file, storage_options=storage_options, desc=download_desc, disable_tqdm=disable_tqdm
+                )
+            else:
+                http_get(
+                    url,
+                    temp_file=temp_file,
+                    proxies=proxies,
+                    resume_size=resume_size,
+                    headers=headers,
+                    cookies=cookies,
+                    max_retries=max_retries,
+                    desc=download_desc,
+                    disable_tqdm=disable_tqdm,
+                )
+
+        logger.info(f"storing {url} in cache at {cache_path}")
+        shutil.move(temp_file.name, cache_path)
+        umask = os.umask(0o666)
+        os.umask(umask)
+        os.chmod(cache_path, 0o666 & ~umask)
+
+        logger.info(f"creating metadata file for {cache_path}")
+        meta = {"url": url, "etag": etag}
+        meta_path = cache_path + ".json"
+        with open(meta_path, "w", encoding="utf-8") as meta_file:
+            json.dump(meta, meta_file)
+
+    return cache_path
+
+
+def add_start_docstrings(*docstr):
+    def docstring_decorator(fn):
+        fn.__doc__ = "".join(docstr) + "\n\n" + (fn.__doc__ if fn.__doc__ is not None else "")
+        return fn
+
+    return docstring_decorator
+
+
+def add_end_docstrings(*docstr):
+    def docstring_decorator(fn):
+        fn.__doc__ = (fn.__doc__ if fn.__doc__ is not None else "") + "\n\n" + "".join(docstr)
+        return fn
+
+    return docstring_decorator
+
+
+def estimate_dataset_size(paths):
+    return sum(path.stat().st_size for path in paths)
+
+
+def readline(f: io.RawIOBase):
+    # From: https://github.com/python/cpython/blob/d27e2f4d118e7a9909b6a3e5da06c5ff95806a85/Lib/_pyio.py#L525
+    res = bytearray()
+    while True:
+        b = f.read(1)
+        if not b:
+            break
+        res += b
+        if res.endswith(b"\n"):
+            break
+    return bytes(res)
+
+
+#######################
+# Streaming utilities #
+#######################
+
+BASE_KNOWN_EXTENSIONS = [
+    "txt",
+    "csv",
+    "json",
+    "jsonl",
+    "tsv",
+    "conll",
+    "conllu",
+    "orig",
+    "parquet",
+    "pkl",
+    "pickle",
+    "rel",
+    "xml",
+]
+COMPRESSION_EXTENSION_TO_PROTOCOL = {
+    # single file compression
+    **{fs_class.extension.lstrip("."): fs_class.protocol for fs_class in COMPRESSION_FILESYSTEMS},
+    # archive compression
+    "zip": "zip",
+}
+SINGLE_FILE_COMPRESSION_PROTOCOLS = {fs_class.protocol for fs_class in COMPRESSION_FILESYSTEMS}
+SINGLE_SLASH_AFTER_PROTOCOL_PATTERN = re.compile(r"(?<!:):/")
+
+
+MAGIC_NUMBER_TO_COMPRESSION_PROTOCOL = {
+    bytes.fromhex("504B0304"): "zip",
+    bytes.fromhex("504B0506"): "zip",  # empty archive
+    bytes.fromhex("504B0708"): "zip",  # spanned archive
+    bytes.fromhex("425A68"): "bz2",
+    bytes.fromhex("1F8B"): "gzip",
+    bytes.fromhex("FD377A585A00"): "xz",
+    bytes.fromhex("04224D18"): "lz4",
+    bytes.fromhex("28B52FFD"): "zstd",
+}
+MAGIC_NUMBER_TO_UNSUPPORTED_COMPRESSION_PROTOCOL = {
+    b"Rar!": "rar",
+}
+MAGIC_NUMBER_MAX_LENGTH = max(
+    len(magic_number)
+    for magic_number in chain(MAGIC_NUMBER_TO_COMPRESSION_PROTOCOL, MAGIC_NUMBER_TO_UNSUPPORTED_COMPRESSION_PROTOCOL)
+)
+
+
+class NonStreamableDatasetError(Exception):
+    pass
+
+
+def _get_path_extension(path: str) -> str:
+    # Get extension: https://foo.bar/train.json.gz -> gz
+    extension = path.split(".")[-1]
+    # Remove query params ("dl=1", "raw=true"): gz?dl=1 -> gz
+    # Remove shards infos (".txt_1", ".txt-00000-of-00100"): txt_1 -> txt
+    for symb in "?-_":
+        extension = extension.split(symb)[0]
+    return extension
+
+
+def _get_extraction_protocol_with_magic_number(f) -> Optional[str]:
+    """read the magic number from a file-like object and return the compression protocol"""
+    # Check if the file object is seekable even before reading the magic number (to avoid https://bugs.python.org/issue26440)
+    try:
+        f.seek(0)
+    except (AttributeError, io.UnsupportedOperation):
+        return None
+    magic_number = f.read(MAGIC_NUMBER_MAX_LENGTH)
+    f.seek(0)
+    for i in range(MAGIC_NUMBER_MAX_LENGTH):
+        compression = MAGIC_NUMBER_TO_COMPRESSION_PROTOCOL.get(magic_number[: MAGIC_NUMBER_MAX_LENGTH - i])
+        if compression is not None:
+            return compression
+        compression = MAGIC_NUMBER_TO_UNSUPPORTED_COMPRESSION_PROTOCOL.get(magic_number[: MAGIC_NUMBER_MAX_LENGTH - i])
+        if compression is not None:
+            raise NotImplementedError(f"Compression protocol '{compression}' not implemented.")
+
+
+def _get_extraction_protocol(urlpath: str, download_config: Optional[DownloadConfig] = None) -> Optional[str]:
+    # get inner file: zip://train-00000.json.gz::https://foo.bar/data.zip -> zip://train-00000.json.gz
+    urlpath = str(urlpath)
+    path = urlpath.split("::")[0]
+    extension = _get_path_extension(path)
+    if (
+        extension in BASE_KNOWN_EXTENSIONS
+        or extension in ["tgz", "tar"]
+        or path.endswith((".tar.gz", ".tar.bz2", ".tar.xz"))
+    ):
+        return None
+    elif extension in COMPRESSION_EXTENSION_TO_PROTOCOL:
+        return COMPRESSION_EXTENSION_TO_PROTOCOL[extension]
+    urlpath, storage_options = _prepare_path_and_storage_options(urlpath, download_config=download_config)
+    try:
+        with fsspec.open(urlpath, **(storage_options or {})) as f:
+            return _get_extraction_protocol_with_magic_number(f)
+    except FileNotFoundError:
+        if urlpath.startswith(config.HF_ENDPOINT):
+            raise FileNotFoundError(
+                urlpath + "\nIf the repo is private or gated, make sure to log in with `huggingface-cli login`."
+            ) from None
+        else:
+            raise
+
+
+def xjoin(a, *p):
+    """
+    This function extends os.path.join to support the "::" hop separator. It supports both paths and urls.
+
+    A shorthand, particularly useful where you have multiple hops, is to “chain” the URLs with the special separator "::".
+    This is used to access files inside a zip file over http for example.
+
+    Let's say you have a zip file at https://host.com/archive.zip, and you want to access the file inside the zip file at /folder1/file.txt.
+    Then you can just chain the url this way:
+
+        zip://folder1/file.txt::https://host.com/archive.zip
+
+    The xjoin function allows you to apply the join on the first path of the chain.
+
+    Example::
+
+        >>> xjoin("zip://folder1::https://host.com/archive.zip", "file.txt")
+        zip://folder1/file.txt::https://host.com/archive.zip
+    """
+    a, *b = str(a).split("::")
+    if is_local_path(a):
+        return os.path.join(a, *p)
+    else:
+        a = posixpath.join(a, *p)
+        return "::".join([a] + b)
+
+
+def xdirname(a):
+    """
+    This function extends os.path.dirname to support the "::" hop separator. It supports both paths and urls.
+
+    A shorthand, particularly useful where you have multiple hops, is to “chain” the URLs with the special separator "::".
+    This is used to access files inside a zip file over http for example.
+
+    Let's say you have a zip file at https://host.com/archive.zip, and you want to access the file inside the zip file at /folder1/file.txt.
+    Then you can just chain the url this way:
+
+        zip://folder1/file.txt::https://host.com/archive.zip
+
+    The xdirname function allows you to apply the dirname on the first path of the chain.
+
+    Example::
+
+        >>> xdirname("zip://folder1/file.txt::https://host.com/archive.zip")
+        zip://folder1::https://host.com/archive.zip
+    """
+    a, *b = str(a).split("::")
+    if is_local_path(a):
+        a = os.path.dirname(Path(a).as_posix())
+    else:
+        a = posixpath.dirname(a)
+    # if we end up at the root of the protocol, we get for example a = 'http:'
+    # so we have to fix it by adding the '//' that was removed:
+    if a.endswith(":"):
+        a += "//"
+    return "::".join([a] + b)
+
+
+def xexists(urlpath: str, download_config: Optional[DownloadConfig] = None):
+    """Extend `os.path.exists` function to support both local and remote files.
+
+    Args:
+        urlpath (`str`): URL path.
+        download_config : mainly use token or storage_options to support different platforms and auth types.
+
+    Returns:
+        `bool`
+    """
+
+    main_hop, *rest_hops = _as_str(urlpath).split("::")
+    if is_local_path(main_hop):
+        return os.path.exists(main_hop)
+    else:
+        urlpath, storage_options = _prepare_path_and_storage_options(urlpath, download_config=download_config)
+        main_hop, *rest_hops = urlpath.split("::")
+        fs, *_ = url_to_fs(urlpath, **storage_options)
+        return fs.exists(main_hop)
+
+
+def xbasename(a):
+    """
+    This function extends os.path.basename to support the "::" hop separator. It supports both paths and urls.
+
+    A shorthand, particularly useful where you have multiple hops, is to “chain” the URLs with the special separator "::".
+    This is used to access files inside a zip file over http for example.
+
+    Let's say you have a zip file at https://host.com/archive.zip, and you want to access the file inside the zip file at /folder1/file.txt.
+    Then you can just chain the url this way:
+
+        zip://folder1/file.txt::https://host.com/archive.zip
+
+    The xbasename function allows you to apply the basename on the first path of the chain.
+
+    Example::
+
+        >>> xbasename("zip://folder1/file.txt::https://host.com/archive.zip")
+        file.txt
+    """
+    a, *b = str(a).split("::")
+    if is_local_path(a):
+        return os.path.basename(Path(a).as_posix())
+    else:
+        return posixpath.basename(a)
+
+
+def xsplit(a):
+    """
+    This function extends os.path.split to support the "::" hop separator. It supports both paths and urls.
+
+    A shorthand, particularly useful where you have multiple hops, is to “chain” the URLs with the special separator "::".
+    This is used to access files inside a zip file over http for example.
+
+    Let's say you have a zip file at https://host.com/archive.zip, and you want to access the file inside the zip file at /folder1/file.txt.
+    Then you can just chain the url this way:
+
+        zip://folder1/file.txt::https://host.com/archive.zip
+
+    The xsplit function allows you to apply the xsplit on the first path of the chain.
+
+    Example::
+
+        >>> xsplit("zip://folder1/file.txt::https://host.com/archive.zip")
+        ('zip://folder1::https://host.com/archive.zip', 'file.txt')
+    """
+    a, *b = str(a).split("::")
+    if is_local_path(a):
+        return os.path.split(Path(a).as_posix())
+    else:
+        a, tail = posixpath.split(a)
+        return "::".join([a + "//" if a.endswith(":") else a] + b), tail
+
+
+def xsplitext(a):
+    """
+    This function extends os.path.splitext to support the "::" hop separator. It supports both paths and urls.
+
+    A shorthand, particularly useful where you have multiple hops, is to “chain” the URLs with the special separator "::".
+    This is used to access files inside a zip file over http for example.
+
+    Let's say you have a zip file at https://host.com/archive.zip, and you want to access the file inside the zip file at /folder1/file.txt.
+    Then you can just chain the url this way:
+
+        zip://folder1/file.txt::https://host.com/archive.zip
+
+    The xsplitext function allows you to apply the splitext on the first path of the chain.
+
+    Example::
+
+        >>> xsplitext("zip://folder1/file.txt::https://host.com/archive.zip")
+        ('zip://folder1/file::https://host.com/archive.zip', '.txt')
+    """
+    a, *b = str(a).split("::")
+    if is_local_path(a):
+        return os.path.splitext(Path(a).as_posix())
+    else:
+        a, ext = posixpath.splitext(a)
+        return "::".join([a] + b), ext
+
+
+def xisfile(path, download_config: Optional[DownloadConfig] = None) -> bool:
+    """Extend `os.path.isfile` function to support remote files.
+
+    Args:
+        path (`str`): URL path.
+        download_config : mainly use token or storage_options to support different platforms and auth types.
+
+    Returns:
+        `bool`
+    """
+    main_hop, *rest_hops = str(path).split("::")
+    if is_local_path(main_hop):
+        return os.path.isfile(path)
+    else:
+        path, storage_options = _prepare_path_and_storage_options(path, download_config=download_config)
+        main_hop, *rest_hops = path.split("::")
+        fs, *_ = url_to_fs(path, **storage_options)
+        return fs.isfile(main_hop)
+
+
+def xgetsize(path, download_config: Optional[DownloadConfig] = None) -> int:
+    """Extend `os.path.getsize` function to support remote files.
+
+    Args:
+        path (`str`): URL path.
+        download_config : mainly use token or storage_options to support different platforms and auth types.
+
+    Returns:
+        `int`: optional
+    """
+    main_hop, *rest_hops = str(path).split("::")
+    if is_local_path(main_hop):
+        return os.path.getsize(path)
+    else:
+        path, storage_options = _prepare_path_and_storage_options(path, download_config=download_config)
+        main_hop, *rest_hops = path.split("::")
+        fs, *_ = fs, *_ = url_to_fs(path, **storage_options)
+        try:
+            size = fs.size(main_hop)
+        except EntryNotFoundError:
+            raise FileNotFoundError(f"No such file: {path}")
+        if size is None:
+            # use xopen instead of fs.open to make data fetching more robust
+            with xopen(path, download_config=download_config) as f:
+                size = len(f.read())
+        return size
+
+
+def xisdir(path, download_config: Optional[DownloadConfig] = None) -> bool:
+    """Extend `os.path.isdir` function to support remote files.
+
+    Args:
+        path (`str`): URL path.
+        download_config : mainly use token or storage_options to support different platforms and auth types.
+
+    Returns:
+        `bool`
+    """
+    main_hop, *rest_hops = str(path).split("::")
+    if is_local_path(main_hop):
+        return os.path.isdir(path)
+    else:
+        path, storage_options = _prepare_path_and_storage_options(path, download_config=download_config)
+        main_hop, *rest_hops = path.split("::")
+        fs, *_ = fs, *_ = url_to_fs(path, **storage_options)
+        inner_path = main_hop.split("://")[-1]
+        if not inner_path.strip("/"):
+            return True
+        return fs.isdir(inner_path)
+
+
+def xrelpath(path, start=None):
+    """Extend `os.path.relpath` function to support remote files.
+
+    Args:
+        path (`str`): URL path.
+        start (`str`): Start URL directory path.
+
+    Returns:
+        `str`
+    """
+    main_hop, *rest_hops = str(path).split("::")
+    if is_local_path(main_hop):
+        return os.path.relpath(main_hop, start=start) if start else os.path.relpath(main_hop)
+    else:
+        return posixpath.relpath(main_hop, start=str(start).split("::")[0]) if start else os.path.relpath(main_hop)
+
+
+def _add_retries_to_file_obj_read_method(file_obj):
+    read = file_obj.read
+    max_retries = config.STREAMING_READ_MAX_RETRIES
+
+    def read_with_retries(*args, **kwargs):
+        disconnect_err = None
+        for retry in range(1, max_retries + 1):
+            try:
+                out = read(*args, **kwargs)
+                break
+            except (ClientError, TimeoutError) as err:
+                disconnect_err = err
+                logger.warning(
+                    f"Got disconnected from remote data host. Retrying in {config.STREAMING_READ_RETRY_INTERVAL}sec [{retry}/{max_retries}]"
+                )
+                time.sleep(config.STREAMING_READ_RETRY_INTERVAL)
+        else:
+            raise ConnectionError("Server Disconnected") from disconnect_err
+        return out
+
+    try:
+        file_obj.read = read_with_retries
+    except AttributeError:  # read-only attribute
+        orig_file_obj = file_obj
+        file_obj = io.RawIOBase()
+        file_obj.read = read_with_retries
+        file_obj.__getattr__ = lambda _, attr: getattr(orig_file_obj, attr)
+    return file_obj
+
+
+def _prepare_path_and_storage_options(
+    urlpath: str, download_config: Optional[DownloadConfig] = None
+) -> Tuple[str, Dict[str, Dict[str, Any]]]:
+    prepared_urlpath = []
+    prepared_storage_options = {}
+    for hop in urlpath.split("::"):
+        hop, storage_options = _prepare_single_hop_path_and_storage_options(hop, download_config=download_config)
+        prepared_urlpath.append(hop)
+        prepared_storage_options.update(storage_options)
+    return "::".join(prepared_urlpath), storage_options
+
+
+def _prepare_single_hop_path_and_storage_options(
+    urlpath: str, download_config: Optional[DownloadConfig] = None
+) -> Tuple[str, Dict[str, Dict[str, Any]]]:
+    """
+    Prepare the URL and the kwargs that must be passed to the HttpFileSystem or to requests.get/head
+
+    In particular it resolves google drive URLs
+    It also adds the authentication headers for the Hugging Face Hub, for both https:// and hf:// paths.
+
+    Storage options are formatted in the form {protocol: storage_options_for_protocol}
+    """
+    token = None if download_config is None else download_config.token
+    if urlpath.startswith(config.HF_ENDPOINT) and "/resolve/" in urlpath:
+        urlpath = "hf://" + urlpath[len(config.HF_ENDPOINT) + 1 :].replace("/resolve/", "@", 1)
+    protocol = urlpath.split("://")[0] if "://" in urlpath else "file"
+    if download_config is not None and protocol in download_config.storage_options:
+        storage_options = download_config.storage_options[protocol]
+    elif download_config is not None and protocol not in download_config.storage_options:
+        storage_options = {
+            option_name: option_value
+            for option_name, option_value in download_config.storage_options.items()
+            if option_name not in fsspec.available_protocols()
+        }
+    else:
+        storage_options = {}
+    if storage_options:
+        storage_options = {protocol: storage_options}
+    if protocol in ["http", "https"]:
+        storage_options[protocol] = {
+            "headers": {
+                **get_authentication_headers_for_url(urlpath, token=token),
+                "user-agent": get_datasets_user_agent(),
+            },
+            "client_kwargs": {"trust_env": True},  # Enable reading proxy env variables.
+            **(storage_options.get(protocol, {})),
+        }
+        if "drive.google.com" in urlpath:
+            response = http_head(urlpath)
+            cookies = None
+            for k, v in response.cookies.items():
+                if k.startswith("download_warning"):
+                    urlpath += "&confirm=" + v
+                    cookies = response.cookies
+                    storage_options[protocol] = {"cookies": cookies, **storage_options.get(protocol, {})}
+        # Fix Google Drive URL to avoid Virus scan warning
+        if "drive.google.com" in urlpath and "confirm=" not in urlpath:
+            urlpath += "&confirm=t"
+        if urlpath.startswith("https://raw.githubusercontent.com/"):
+            # Workaround for served data with gzip content-encoding: https://github.com/fsspec/filesystem_spec/issues/389
+            storage_options[protocol]["headers"]["Accept-Encoding"] = "identity"
+    elif protocol == "hf":
+        storage_options[protocol] = {
+            "token": token,
+            "endpoint": config.HF_ENDPOINT,
+            **storage_options.get(protocol, {}),
+        }
+        # streaming with block_size=0 is only implemented in 0.21 (see https://github.com/huggingface/huggingface_hub/pull/1967)
+        if config.HF_HUB_VERSION < version.parse("0.21.0"):
+            storage_options[protocol]["block_size"] = "default"
+    return urlpath, storage_options
+
+
+def xopen(file: str, mode="r", *args, download_config: Optional[DownloadConfig] = None, **kwargs):
+    """Extend `open` function to support remote files using `fsspec`.
+
+    It also has a retry mechanism in case connection fails.
+    The `args` and `kwargs` are passed to `fsspec.open`, except `token` which is used for queries to private repos on huggingface.co
+
+    Args:
+        file (`str`): Path name of the file to be opened.
+        mode (`str`, *optional*, default "r"): Mode in which the file is opened.
+        *args: Arguments to be passed to `fsspec.open`.
+        download_config : mainly use token or storage_options to support different platforms and auth types.
+        **kwargs: Keyword arguments to be passed to `fsspec.open`.
+
+    Returns:
+        file object
+    """
+    # This works as well for `xopen(str(Path(...)))`
+    file_str = _as_str(file)
+    main_hop, *rest_hops = file_str.split("::")
+    if is_local_path(main_hop):
+        # ignore fsspec-specific kwargs
+        kwargs.pop("block_size", None)
+        return open(main_hop, mode, *args, **kwargs)
+    # add headers and cookies for authentication on the HF Hub and for Google Drive
+    file, storage_options = _prepare_path_and_storage_options(file_str, download_config=download_config)
+    kwargs = {**kwargs, **(storage_options or {})}
+    try:
+        file_obj = fsspec.open(file, mode=mode, *args, **kwargs).open()
+    except ValueError as e:
+        if str(e) == "Cannot seek streaming HTTP file":
+            raise NonStreamableDatasetError(
+                "Streaming is not possible for this dataset because data host server doesn't support HTTP range "
+                "requests. You can still load this dataset in non-streaming mode by passing `streaming=False` (default)"
+            ) from e
+        else:
+            raise
+    except FileNotFoundError:
+        if file.startswith(config.HF_ENDPOINT):
+            raise FileNotFoundError(
+                file + "\nIf the repo is private or gated, make sure to log in with `huggingface-cli login`."
+            ) from None
+        else:
+            raise
+    file_obj = _add_retries_to_file_obj_read_method(file_obj)
+    return file_obj
+
+
+def xlistdir(path: str, download_config: Optional[DownloadConfig] = None) -> List[str]:
+    """Extend `os.listdir` function to support remote files.
+
+    Args:
+        path (`str`): URL path.
+        download_config : mainly use token or storage_options to support different platforms and auth types.
+
+    Returns:
+        `list` of `str`
+    """
+    main_hop, *rest_hops = _as_str(path).split("::")
+    if is_local_path(main_hop):
+        return os.listdir(path)
+    else:
+        # globbing inside a zip in a private repo requires authentication
+        path, storage_options = _prepare_path_and_storage_options(path, download_config=download_config)
+        main_hop, *rest_hops = path.split("::")
+        fs, *_ = url_to_fs(path, **storage_options)
+        inner_path = main_hop.split("://")[-1]
+        if inner_path.strip("/") and not fs.isdir(inner_path):
+            raise FileNotFoundError(f"Directory doesn't exist: {path}")
+        paths = fs.listdir(inner_path, detail=False)
+        return [os.path.basename(path.rstrip("/")) for path in paths]
+
+
+def xglob(urlpath, *, recursive=False, download_config: Optional[DownloadConfig] = None):
+    """Extend `glob.glob` function to support remote files.
+
+    Args:
+        urlpath (`str`): URL path with shell-style wildcard patterns.
+        recursive (`bool`, default `False`): Whether to match the "**" pattern recursively to zero or more
+            directories or subdirectories.
+        download_config : mainly use token or storage_options to support different platforms and auth types.
+
+    Returns:
+        `list` of `str`
+    """
+    main_hop, *rest_hops = _as_str(urlpath).split("::")
+    if is_local_path(main_hop):
+        return glob.glob(main_hop, recursive=recursive)
+    else:
+        # globbing inside a zip in a private repo requires authentication
+        urlpath, storage_options = _prepare_path_and_storage_options(urlpath, download_config=download_config)
+        main_hop, *rest_hops = urlpath.split("::")
+        fs, *_ = url_to_fs(urlpath, **storage_options)
+        inner_path = main_hop.split("://")[1]
+        globbed_paths = fs.glob(inner_path)
+        protocol = fs.protocol if isinstance(fs.protocol, str) else fs.protocol[-1]
+        return ["::".join([f"{protocol}://{globbed_path}"] + rest_hops) for globbed_path in globbed_paths]
+
+
+def xwalk(urlpath, download_config: Optional[DownloadConfig] = None, **kwargs):
+    """Extend `os.walk` function to support remote files.
+
+    Args:
+        urlpath (`str`): URL root path.
+        download_config : mainly use token or storage_options to support different platforms and auth types.
+        **kwargs: Additional keyword arguments forwarded to the underlying filesystem.
+
+
+    Yields:
+        `tuple`: 3-tuple (dirpath, dirnames, filenames).
+    """
+    main_hop, *rest_hops = _as_str(urlpath).split("::")
+    if is_local_path(main_hop):
+        yield from os.walk(main_hop, **kwargs)
+    else:
+        # walking inside a zip in a private repo requires authentication
+        urlpath, storage_options = _prepare_path_and_storage_options(urlpath, download_config=download_config)
+        main_hop, *rest_hops = urlpath.split("::")
+        fs, *_ = url_to_fs(urlpath, **storage_options)
+        inner_path = main_hop.split("://")[-1]
+        if inner_path.strip("/") and not fs.isdir(inner_path):
+            return []
+        protocol = fs.protocol if isinstance(fs.protocol, str) else fs.protocol[-1]
+        for dirpath, dirnames, filenames in fs.walk(inner_path, **kwargs):
+            yield "::".join([f"{protocol}://{dirpath}"] + rest_hops), dirnames, filenames
+
+
+class xPath(type(Path())):
+    """Extension of `pathlib.Path` to support both local paths and remote URLs."""
+
+    def __str__(self):
+        path_str = super().__str__()
+        main_hop, *rest_hops = path_str.split("::")
+        if is_local_path(main_hop):
+            return main_hop
+        path_as_posix = path_str.replace("\\", "/")
+        path_as_posix = SINGLE_SLASH_AFTER_PROTOCOL_PATTERN.sub("://", path_as_posix)
+        path_as_posix += "//" if path_as_posix.endswith(":") else ""  # Add slashes to root of the protocol
+        return path_as_posix
+
+    def exists(self, download_config: Optional[DownloadConfig] = None):
+        """Extend `pathlib.Path.exists` method to support both local and remote files.
+
+        Args:
+            download_config : mainly use token or storage_options to support different platforms and auth types.
+
+        Returns:
+            `bool`
+        """
+        return xexists(str(self), download_config=download_config)
+
+    def glob(self, pattern, download_config: Optional[DownloadConfig] = None):
+        """Glob function for argument of type :obj:`~pathlib.Path` that supports both local paths end remote URLs.
+
+        Args:
+            pattern (`str`): Pattern that resulting paths must match.
+            download_config : mainly use token or storage_options to support different platforms and auth types.
+
+        Yields:
+            [`xPath`]
+        """
+        posix_path = self.as_posix()
+        main_hop, *rest_hops = posix_path.split("::")
+        if is_local_path(main_hop):
+            yield from Path(main_hop).glob(pattern)
+        else:
+            # globbing inside a zip in a private repo requires authentication
+            if rest_hops:
+                urlpath = rest_hops[0]
+                urlpath, storage_options = _prepare_path_and_storage_options(urlpath, download_config=download_config)
+                storage_options = {urlpath.split("://")[0]: storage_options}
+                posix_path = "::".join([main_hop, urlpath, *rest_hops[1:]])
+            else:
+                storage_options = None
+            fs, *_ = url_to_fs(xjoin(posix_path, pattern), **(storage_options or {}))
+            globbed_paths = fs.glob(xjoin(main_hop, pattern))
+            for globbed_path in globbed_paths:
+                yield type(self)("::".join([f"{fs.protocol}://{globbed_path}"] + rest_hops))
+
+    def rglob(self, pattern, **kwargs):
+        """Rglob function for argument of type :obj:`~pathlib.Path` that supports both local paths end remote URLs.
+
+        Args:
+            pattern (`str`): Pattern that resulting paths must match.
+
+        Yields:
+            [`xPath`]
+        """
+        return self.glob("**/" + pattern, **kwargs)
+
+    @property
+    def parent(self) -> "xPath":
+        """Name function for argument of type :obj:`~pathlib.Path` that supports both local paths end remote URLs.
+
+        Returns:
+            [`xPath`]
+        """
+        return type(self)(xdirname(self.as_posix()))
+
+    @property
+    def name(self) -> str:
+        """Name function for argument of type :obj:`~pathlib.Path` that supports both local paths end remote URLs.
+
+        Returns:
+            `str`
+        """
+        return PurePosixPath(self.as_posix().split("::")[0]).name
+
+    @property
+    def stem(self) -> str:
+        """Stem function for argument of type :obj:`~pathlib.Path` that supports both local paths end remote URLs.
+
+        Returns:
+            `str`
+        """
+        return PurePosixPath(self.as_posix().split("::")[0]).stem
+
+    @property
+    def suffix(self) -> str:
+        """Suffix function for argument of type :obj:`~pathlib.Path` that supports both local paths end remote URLs.
+
+        Returns:
+            `str`
+        """
+        return PurePosixPath(self.as_posix().split("::")[0]).suffix
+
+    def open(self, *args, **kwargs):
+        """Extend :func:`xopen` to support argument of type :obj:`~pathlib.Path`.
+
+        Args:
+            **args: Arguments passed to :func:`fsspec.open`.
+            **kwargs: Keyword arguments passed to :func:`fsspec.open`.
+
+        Returns:
+            `io.FileIO`: File-like object.
+        """
+        return xopen(str(self), *args, **kwargs)
+
+    def joinpath(self, *p: Tuple[str, ...]) -> "xPath":
+        """Extend :func:`xjoin` to support argument of type :obj:`~pathlib.Path`.
+
+        Args:
+            *p (`tuple` of `str`): Other path components.
+
+        Returns:
+            [`xPath`]
+        """
+        return type(self)(xjoin(self.as_posix(), *p))
+
+    def __truediv__(self, p: str) -> "xPath":
+        return self.joinpath(p)
+
+    def with_suffix(self, suffix):
+        main_hop, *rest_hops = str(self).split("::")
+        if is_local_path(main_hop):
+            return type(self)(str(super().with_suffix(suffix)))
+        return type(self)("::".join([type(self)(PurePosixPath(main_hop).with_suffix(suffix)).as_posix()] + rest_hops))
+
+
+def _as_str(path: Union[str, Path, xPath]):
+    return str(path) if isinstance(path, xPath) else str(xPath(str(path)))
+
+
+def xgzip_open(filepath_or_buffer, *args, download_config: Optional[DownloadConfig] = None, **kwargs):
+    import gzip
+
+    if hasattr(filepath_or_buffer, "read"):
+        return gzip.open(filepath_or_buffer, *args, **kwargs)
+    else:
+        filepath_or_buffer = str(filepath_or_buffer)
+        return gzip.open(xopen(filepath_or_buffer, "rb", download_config=download_config), *args, **kwargs)
+
+
+def xnumpy_load(filepath_or_buffer, *args, download_config: Optional[DownloadConfig] = None, **kwargs):
+    import numpy as np
+
+    if hasattr(filepath_or_buffer, "read"):
+        return np.load(filepath_or_buffer, *args, **kwargs)
+    else:
+        filepath_or_buffer = str(filepath_or_buffer)
+        return np.load(xopen(filepath_or_buffer, "rb", download_config=download_config), *args, **kwargs)
+
+
+def xpandas_read_csv(filepath_or_buffer, download_config: Optional[DownloadConfig] = None, **kwargs):
+    import pandas as pd
+
+    if hasattr(filepath_or_buffer, "read"):
+        return pd.read_csv(filepath_or_buffer, **kwargs)
+    else:
+        filepath_or_buffer = str(filepath_or_buffer)
+        if kwargs.get("compression", "infer") == "infer":
+            kwargs["compression"] = _get_extraction_protocol(filepath_or_buffer, download_config=download_config)
+        return pd.read_csv(xopen(filepath_or_buffer, "rb", download_config=download_config), **kwargs)
+
+
+def xpandas_read_excel(filepath_or_buffer, download_config: Optional[DownloadConfig] = None, **kwargs):
+    import pandas as pd
+
+    if hasattr(filepath_or_buffer, "read"):
+        try:
+            return pd.read_excel(filepath_or_buffer, **kwargs)
+        except ValueError:  # Cannot seek streaming HTTP file
+            return pd.read_excel(BytesIO(filepath_or_buffer.read()), **kwargs)
+    else:
+        filepath_or_buffer = str(filepath_or_buffer)
+        try:
+            return pd.read_excel(xopen(filepath_or_buffer, "rb", download_config=download_config), **kwargs)
+        except ValueError:  # Cannot seek streaming HTTP file
+            return pd.read_excel(
+                BytesIO(xopen(filepath_or_buffer, "rb", download_config=download_config).read()), **kwargs
+            )
+
+
+def xpyarrow_parquet_read_table(filepath_or_buffer, download_config: Optional[DownloadConfig] = None, **kwargs):
+    import pyarrow.parquet as pq
+
+    if hasattr(filepath_or_buffer, "read"):
+        return pq.read_table(filepath_or_buffer, **kwargs)
+    else:
+        filepath_or_buffer = str(filepath_or_buffer)
+        return pq.read_table(xopen(filepath_or_buffer, mode="rb", download_config=download_config), **kwargs)
+
+
+def xsio_loadmat(filepath_or_buffer, download_config: Optional[DownloadConfig] = None, **kwargs):
+    import scipy.io as sio
+
+    if hasattr(filepath_or_buffer, "read"):
+        return sio.loadmat(filepath_or_buffer, **kwargs)
+    else:
+        return sio.loadmat(xopen(filepath_or_buffer, "rb", download_config=download_config), **kwargs)
+
+
+def xet_parse(source, parser=None, download_config: Optional[DownloadConfig] = None):
+    """Extend `xml.etree.ElementTree.parse` function to support remote files.
+
+    Args:
+        source: File path or file object.
+        parser (`XMLParser`, *optional*, default `XMLParser`): Parser instance.
+        download_config : mainly use token or storage_options to support different platforms and auth types.
+
+    Returns:
+        `xml.etree.ElementTree.Element`: Root element of the given source document.
+    """
+    if hasattr(source, "read"):
+        return ET.parse(source, parser=parser)
+    else:
+        with xopen(source, "rb", download_config=download_config) as f:
+            return ET.parse(f, parser=parser)
+
+
+def xxml_dom_minidom_parse(filename_or_file, download_config: Optional[DownloadConfig] = None, **kwargs):
+    """Extend `xml.dom.minidom.parse` function to support remote files.
+
+    Args:
+        filename_or_file (`str` or file): File path or file object.
+        download_config : mainly use token or storage_options to support different platforms and auth types.
+        **kwargs (optional): Additional keyword arguments passed to `xml.dom.minidom.parse`.
+
+    Returns:
+        :obj:`xml.dom.minidom.Document`: Parsed document.
+    """
+    if hasattr(filename_or_file, "read"):
+        return xml.dom.minidom.parse(filename_or_file, **kwargs)
+    else:
+        with xopen(filename_or_file, "rb", download_config=download_config) as f:
+            return xml.dom.minidom.parse(f, **kwargs)
+
+
+class _IterableFromGenerator(TrackedIterable):
+    """Utility class to create an iterable from a generator function, in order to reset the generator when needed."""
+
+    def __init__(self, generator: Callable, *args, **kwargs):
+        super().__init__()
+        self.generator = generator
+        self.args = args
+        self.kwargs = kwargs
+
+    def __iter__(self):
+        for x in self.generator(*self.args, **self.kwargs):
+            self.last_item = x
+            yield x
+        self.last_item = None
+
+
+class ArchiveIterable(_IterableFromGenerator):
+    """An iterable of (path, fileobj) from a TAR archive, used by `iter_archive`"""
+
+    @staticmethod
+    def _iter_tar(f):
+        stream = tarfile.open(fileobj=f, mode="r|*")
+        for tarinfo in stream:
+            file_path = tarinfo.name
+            if not tarinfo.isreg():
+                continue
+            if file_path is None:
+                continue
+            if os.path.basename(file_path).startswith((".", "__")):
+                # skipping hidden files
+                continue
+            file_obj = stream.extractfile(tarinfo)
+            yield file_path, file_obj
+            stream.members = []
+        del stream
+
+    @staticmethod
+    def _iter_zip(f):
+        zipf = zipfile.ZipFile(f)
+        for member in zipf.infolist():
+            file_path = member.filename
+            if member.is_dir():
+                continue
+            if file_path is None:
+                continue
+            if os.path.basename(file_path).startswith((".", "__")):
+                # skipping hidden files
+                continue
+            file_obj = zipf.open(member)
+            yield file_path, file_obj
+
+    @classmethod
+    def _iter_from_fileobj(cls, f) -> Generator[Tuple, None, None]:
+        compression = _get_extraction_protocol_with_magic_number(f)
+        if compression == "zip":
+            yield from cls._iter_zip(f)
+        else:
+            yield from cls._iter_tar(f)
+
+    @classmethod
+    def _iter_from_urlpath(
+        cls, urlpath: str, download_config: Optional[DownloadConfig] = None
+    ) -> Generator[Tuple, None, None]:
+        compression = _get_extraction_protocol(urlpath, download_config=download_config)
+        # Set block_size=0 to get faster streaming
+        # (e.g. for hf:// and https:// it uses streaming Requests file-like instances)
+        with xopen(urlpath, "rb", download_config=download_config, block_size=0) as f:
+            if compression == "zip":
+                yield from cls._iter_zip(f)
+            else:
+                yield from cls._iter_tar(f)
+
+    @classmethod
+    def from_buf(cls, fileobj) -> "ArchiveIterable":
+        return cls(cls._iter_from_fileobj, fileobj)
+
+    @classmethod
+    def from_urlpath(cls, urlpath_or_buf, download_config: Optional[DownloadConfig] = None) -> "ArchiveIterable":
+        return cls(cls._iter_from_urlpath, urlpath_or_buf, download_config)
+
+
+class FilesIterable(_IterableFromGenerator):
+    """An iterable of paths from a list of directories or files"""
+
+    @classmethod
+    def _iter_from_urlpaths(
+        cls, urlpaths: Union[str, List[str]], download_config: Optional[DownloadConfig] = None
+    ) -> Generator[str, None, None]:
+        if not isinstance(urlpaths, list):
+            urlpaths = [urlpaths]
+        for urlpath in urlpaths:
+            if xisfile(urlpath, download_config=download_config):
+                yield urlpath
+            elif xisdir(urlpath, download_config=download_config):
+                for dirpath, dirnames, filenames in xwalk(urlpath, download_config=download_config):
+                    # in-place modification to prune the search
+                    dirnames[:] = sorted([dirname for dirname in dirnames if not dirname.startswith((".", "__"))])
+                    if xbasename(dirpath).startswith((".", "__")):
+                        # skipping hidden directories
+                        continue
+                    for filename in sorted(filenames):
+                        if filename.startswith((".", "__")):
+                            # skipping hidden files
+                            continue
+                        yield xjoin(dirpath, filename)
+            else:
+                raise FileNotFoundError(urlpath)
+
+    @classmethod
+    def from_urlpaths(cls, urlpaths, download_config: Optional[DownloadConfig] = None) -> "FilesIterable":
+        return cls(cls._iter_from_urlpaths, urlpaths, download_config)

venv/lib/python3.10/site-packages/datasets/utils/filelock.py

@@ -0,0 +1,11 @@
+# deprecated, please use the `filelock` package instead
+
+from filelock import (  # noqa: F401 # imported for backward compatibility TODO: remove in 3.0.0
+    BaseFileLock,
+    SoftFileLock,
+    Timeout,
+    UnixFileLock,
+    WindowsFileLock,
+)
+
+from ._filelock import FileLock  # noqa: F401 # imported for backward compatibility. TODO: remove in 3.0.0

venv/lib/python3.10/site-packages/datasets/utils/hub.py

@@ -0,0 +1,6 @@
+from functools import partial
+
+from huggingface_hub import hf_hub_url
+
+
+hf_dataset_url = partial(hf_hub_url, repo_type="dataset")

venv/lib/python3.10/site-packages/datasets/utils/info_utils.py

@@ -0,0 +1,130 @@
+import enum
+import os
+from typing import Optional
+
+from huggingface_hub.utils import insecure_hashlib
+
+from .. import config
+from .logging import get_logger
+
+
+logger = get_logger(__name__)
+
+
+class VerificationMode(enum.Enum):
+    """`Enum` that specifies which verification checks to run.
+
+    The default mode is `BASIC_CHECKS`, which will perform only rudimentary checks to avoid slowdowns
+    when generating/downloading a dataset for the first time.
+
+    The verification modes:
+
+    |                           | Verification checks                                                           |
+    |---------------------------|------------------------------------------------------------------------------ |
+    | `ALL_CHECKS`              | Split checks, uniqueness of the keys yielded in case of the GeneratorBuilder  |
+    |                           | and the validity (number of files, checksums, etc.) of downloaded files       |
+    | `BASIC_CHECKS` (default)  | Same as `ALL_CHECKS` but without checking downloaded files                    |
+    | `NO_CHECKS`               | None                                                                          |
+
+    """
+
+    ALL_CHECKS = "all_checks"
+    BASIC_CHECKS = "basic_checks"
+    NO_CHECKS = "no_checks"
+
+
+class ChecksumVerificationException(Exception):
+    """Exceptions during checksums verifications of downloaded files."""
+
+
+class UnexpectedDownloadedFile(ChecksumVerificationException):
+    """Some downloaded files were not expected."""
+
+
+class ExpectedMoreDownloadedFiles(ChecksumVerificationException):
+    """Some files were supposed to be downloaded but were not."""
+
+
+class NonMatchingChecksumError(ChecksumVerificationException):
+    """The downloaded file checksum don't match the expected checksum."""
+
+
+def verify_checksums(expected_checksums: Optional[dict], recorded_checksums: dict, verification_name=None):
+    if expected_checksums is None:
+        logger.info("Unable to verify checksums.")
+        return
+    if len(set(expected_checksums) - set(recorded_checksums)) > 0:
+        raise ExpectedMoreDownloadedFiles(str(set(expected_checksums) - set(recorded_checksums)))
+    if len(set(recorded_checksums) - set(expected_checksums)) > 0:
+        raise UnexpectedDownloadedFile(str(set(recorded_checksums) - set(expected_checksums)))
+    bad_urls = [url for url in expected_checksums if expected_checksums[url] != recorded_checksums[url]]
+    for_verification_name = " for " + verification_name if verification_name is not None else ""
+    if len(bad_urls) > 0:
+        raise NonMatchingChecksumError(
+            f"Checksums didn't match{for_verification_name}:\n"
+            f"{bad_urls}\n"
+            "Set `verification_mode='no_checks'` to skip checksums verification and ignore this error"
+        )
+    logger.info("All the checksums matched successfully" + for_verification_name)
+
+
+class SplitsVerificationException(Exception):
+    """Exceptions during splis verifications"""
+
+
+class UnexpectedSplits(SplitsVerificationException):
+    """The expected splits of the downloaded file is missing."""
+
+
+class ExpectedMoreSplits(SplitsVerificationException):
+    """Some recorded splits are missing."""
+
+
+class NonMatchingSplitsSizesError(SplitsVerificationException):
+    """The splits sizes don't match the expected splits sizes."""
+
+
+def verify_splits(expected_splits: Optional[dict], recorded_splits: dict):
+    if expected_splits is None:
+        logger.info("Unable to verify splits sizes.")
+        return
+    if len(set(expected_splits) - set(recorded_splits)) > 0:
+        raise ExpectedMoreSplits(str(set(expected_splits) - set(recorded_splits)))
+    if len(set(recorded_splits) - set(expected_splits)) > 0:
+        raise UnexpectedSplits(str(set(recorded_splits) - set(expected_splits)))
+    bad_splits = [
+        {"expected": expected_splits[name], "recorded": recorded_splits[name]}
+        for name in expected_splits
+        if expected_splits[name].num_examples != recorded_splits[name].num_examples
+    ]
+    if len(bad_splits) > 0:
+        raise NonMatchingSplitsSizesError(str(bad_splits))
+    logger.info("All the splits matched successfully.")
+
+
+def get_size_checksum_dict(path: str, record_checksum: bool = True) -> dict:
+    """Compute the file size and the sha256 checksum of a file"""
+    if record_checksum:
+        m = insecure_hashlib.sha256()
+        with open(path, "rb") as f:
+            for chunk in iter(lambda: f.read(1 << 20), b""):
+                m.update(chunk)
+            checksum = m.hexdigest()
+    else:
+        checksum = None
+    return {"num_bytes": os.path.getsize(path), "checksum": checksum}
+
+
+def is_small_dataset(dataset_size):
+    """Check if `dataset_size` is smaller than `config.IN_MEMORY_MAX_SIZE`.
+
+    Args:
+        dataset_size (int): Dataset size in bytes.
+
+    Returns:
+        bool: Whether `dataset_size` is smaller than `config.IN_MEMORY_MAX_SIZE`.
+    """
+    if dataset_size and config.IN_MEMORY_MAX_SIZE:
+        return dataset_size < config.IN_MEMORY_MAX_SIZE
+    else:
+        return False

venv/lib/python3.10/site-packages/datasets/utils/metadata.py

@@ -0,0 +1,320 @@
+import re
+import textwrap
+from collections import Counter
+from itertools import groupby
+from operator import itemgetter
+from pathlib import Path
+from typing import Any, ClassVar, Dict, List, Optional, Tuple, Union
+
+import yaml
+from huggingface_hub import DatasetCardData
+
+from ..config import METADATA_CONFIGS_FIELD
+from ..info import DatasetInfo, DatasetInfosDict
+from ..naming import _split_re
+from ..utils.logging import get_logger
+from .deprecation_utils import deprecated
+
+
+logger = get_logger(__name__)
+
+
+class _NoDuplicateSafeLoader(yaml.SafeLoader):
+    def _check_no_duplicates_on_constructed_node(self, node):
+        keys = [self.constructed_objects[key_node] for key_node, _ in node.value]
+        keys = [tuple(key) if isinstance(key, list) else key for key in keys]
+        counter = Counter(keys)
+        duplicate_keys = [key for key in counter if counter[key] > 1]
+        if duplicate_keys:
+            raise TypeError(f"Got duplicate yaml keys: {duplicate_keys}")
+
+    def construct_mapping(self, node, deep=False):
+        mapping = super().construct_mapping(node, deep=deep)
+        self._check_no_duplicates_on_constructed_node(node)
+        return mapping
+
+
+def _split_yaml_from_readme(readme_content: str) -> Tuple[Optional[str], str]:
+    full_content = list(readme_content.splitlines())
+    if full_content and full_content[0] == "---" and "---" in full_content[1:]:
+        sep_idx = full_content[1:].index("---") + 1
+        yamlblock = "\n".join(full_content[1:sep_idx])
+        return yamlblock, "\n".join(full_content[sep_idx + 1 :])
+
+    return None, "\n".join(full_content)
+
+
+@deprecated("Use `huggingface_hub.DatasetCardData` instead.")
+class DatasetMetadata(dict):
+    # class attributes
+    _FIELDS_WITH_DASHES = {"train_eval_index"}  # train-eval-index in the YAML metadata
+
+    @classmethod
+    def from_readme(cls, path: Union[Path, str]) -> "DatasetMetadata":
+        """Loads and validates the dataset metadata from its dataset card (README.md)
+
+        Args:
+            path (:obj:`Path`): Path to the dataset card (its README.md file)
+
+        Returns:
+            :class:`DatasetMetadata`: The dataset's metadata
+
+        Raises:
+            :obj:`TypeError`: If the dataset's metadata is invalid
+        """
+        with open(path, encoding="utf-8") as readme_file:
+            yaml_string, _ = _split_yaml_from_readme(readme_file.read())
+        if yaml_string is not None:
+            return cls.from_yaml_string(yaml_string)
+        else:
+            return cls()
+
+    def to_readme(self, path: Path):
+        if path.exists():
+            with open(path, encoding="utf-8") as readme_file:
+                readme_content = readme_file.read()
+        else:
+            readme_content = None
+        updated_readme_content = self._to_readme(readme_content)
+        with open(path, "w", encoding="utf-8") as readme_file:
+            readme_file.write(updated_readme_content)
+
+    def _to_readme(self, readme_content: Optional[str] = None) -> str:
+        if readme_content is not None:
+            _, content = _split_yaml_from_readme(readme_content)
+            full_content = "---\n" + self.to_yaml_string() + "---\n" + content
+        else:
+            full_content = "---\n" + self.to_yaml_string() + "---\n"
+        return full_content
+
+    @classmethod
+    def from_yaml_string(cls, string: str) -> "DatasetMetadata":
+        """Loads and validates the dataset metadata from a YAML string
+
+        Args:
+            string (:obj:`str`): The YAML string
+
+        Returns:
+            :class:`DatasetMetadata`: The dataset's metadata
+
+        Raises:
+            :obj:`TypeError`: If the dataset's metadata is invalid
+        """
+        metadata_dict = yaml.load(string, Loader=_NoDuplicateSafeLoader) or {}
+
+        # Convert the YAML keys to DatasetMetadata fields
+        metadata_dict = {
+            (key.replace("-", "_") if key.replace("-", "_") in cls._FIELDS_WITH_DASHES else key): value
+            for key, value in metadata_dict.items()
+        }
+        return cls(**metadata_dict)
+
+    def to_yaml_string(self) -> str:
+        return yaml.safe_dump(
+            {
+                (key.replace("_", "-") if key in self._FIELDS_WITH_DASHES else key): value
+                for key, value in self.items()
+            },
+            sort_keys=False,
+            allow_unicode=True,
+            encoding="utf-8",
+        ).decode("utf-8")
+
+
+class MetadataConfigs(Dict[str, Dict[str, Any]]):
+    """Should be in format {config_name: {**config_params}}."""
+
+    FIELD_NAME: ClassVar[str] = METADATA_CONFIGS_FIELD
+
+    @staticmethod
+    def _raise_if_data_files_field_not_valid(metadata_config: dict):
+        yaml_data_files = metadata_config.get("data_files")
+        if yaml_data_files is not None:
+            yaml_error_message = textwrap.dedent(
+                f"""
+                Expected data_files in YAML to be either a string or a list of strings
+                or a list of dicts with two keys: 'split' and 'path', but got {yaml_data_files}
+                Examples of data_files in YAML:
+
+                   data_files: data.csv
+
+                   data_files: data/*.png
+
+                   data_files:
+                    - part0/*
+                    - part1/*
+
+                   data_files:
+                    - split: train
+                      path: train/*
+                    - split: test
+                      path: test/*
+
+                   data_files:
+                    - split: train
+                      path:
+                      - train/part1/*
+                      - train/part2/*
+                    - split: test
+                      path: test/*
+
+                PS: some symbols like dashes '-' are not allowed in split names
+                """
+            )
+            if not isinstance(yaml_data_files, (list, str)):
+                raise ValueError(yaml_error_message)
+            if isinstance(yaml_data_files, list):
+                for yaml_data_files_item in yaml_data_files:
+                    if (
+                        not isinstance(yaml_data_files_item, (str, dict))
+                        or isinstance(yaml_data_files_item, dict)
+                        and not (
+                            len(yaml_data_files_item) == 2
+                            and "split" in yaml_data_files_item
+                            and re.match(_split_re, yaml_data_files_item["split"])
+                            and isinstance(yaml_data_files_item.get("path"), (str, list))
+                        )
+                    ):
+                        raise ValueError(yaml_error_message)
+
+    @classmethod
+    def _from_exported_parquet_files_and_dataset_infos(
+        cls,
+        revision: str,
+        exported_parquet_files: List[Dict[str, Any]],
+        dataset_infos: DatasetInfosDict,
+    ) -> "MetadataConfigs":
+        metadata_configs = {
+            config_name: {
+                "data_files": [
+                    {
+                        "split": split_name,
+                        "path": [
+                            parquet_file["url"].replace("refs%2Fconvert%2Fparquet", revision)
+                            for parquet_file in parquet_files_for_split
+                        ],
+                    }
+                    for split_name, parquet_files_for_split in groupby(parquet_files_for_config, itemgetter("split"))
+                ],
+                "version": str(dataset_infos.get(config_name, DatasetInfo()).version or "0.0.0"),
+            }
+            for config_name, parquet_files_for_config in groupby(exported_parquet_files, itemgetter("config"))
+        }
+        if dataset_infos:
+            # Preserve order of configs and splits
+            metadata_configs = {
+                config_name: {
+                    "data_files": [
+                        data_file
+                        for split_name in dataset_info.splits
+                        for data_file in metadata_configs[config_name]["data_files"]
+                        if data_file["split"] == split_name
+                    ],
+                    "version": metadata_configs[config_name]["version"],
+                }
+                for config_name, dataset_info in dataset_infos.items()
+            }
+        return cls(metadata_configs)
+
+    @classmethod
+    def from_dataset_card_data(cls, dataset_card_data: DatasetCardData) -> "MetadataConfigs":
+        if dataset_card_data.get(cls.FIELD_NAME):
+            metadata_configs = dataset_card_data[cls.FIELD_NAME]
+            if not isinstance(metadata_configs, list):
+                raise ValueError(f"Expected {cls.FIELD_NAME} to be a list, but got '{metadata_configs}'")
+            for metadata_config in metadata_configs:
+                if "config_name" not in metadata_config:
+                    raise ValueError(
+                        f"Each config must include `config_name` field with a string name of a config, "
+                        f"but got {metadata_config}. "
+                    )
+                cls._raise_if_data_files_field_not_valid(metadata_config)
+            return cls(
+                {
+                    config["config_name"]: {param: value for param, value in config.items() if param != "config_name"}
+                    for config in metadata_configs
+                }
+            )
+        return cls()
+
+    def to_dataset_card_data(self, dataset_card_data: DatasetCardData) -> None:
+        if self:
+            for metadata_config in self.values():
+                self._raise_if_data_files_field_not_valid(metadata_config)
+            current_metadata_configs = self.from_dataset_card_data(dataset_card_data)
+            total_metadata_configs = dict(sorted({**current_metadata_configs, **self}.items()))
+            for config_name, config_metadata in total_metadata_configs.items():
+                config_metadata.pop("config_name", None)
+            dataset_card_data[self.FIELD_NAME] = [
+                {"config_name": config_name, **config_metadata}
+                for config_name, config_metadata in total_metadata_configs.items()
+            ]
+
+    def get_default_config_name(self) -> Optional[str]:
+        default_config_name = None
+        for config_name, metadata_config in self.items():
+            if len(self) == 1 or config_name == "default" or metadata_config.get("default"):
+                if default_config_name is None:
+                    default_config_name = config_name
+                else:
+                    raise ValueError(
+                        f"Dataset has several default configs: '{default_config_name}' and '{config_name}'."
+                    )
+        return default_config_name
+
+
+# DEPRECATED - just here to support old versions of evaluate like 0.2.2
+# To support new tasks on the Hugging Face Hub, please open a PR for this file:
+# https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/src/pipelines.ts
+known_task_ids = {
+    "image-classification": [],
+    "translation": [],
+    "image-segmentation": [],
+    "fill-mask": [],
+    "automatic-speech-recognition": [],
+    "token-classification": [],
+    "sentence-similarity": [],
+    "audio-classification": [],
+    "question-answering": [],
+    "summarization": [],
+    "zero-shot-classification": [],
+    "table-to-text": [],
+    "feature-extraction": [],
+    "other": [],
+    "multiple-choice": [],
+    "text-classification": [],
+    "text-to-image": [],
+    "text2text-generation": [],
+    "zero-shot-image-classification": [],
+    "tabular-classification": [],
+    "tabular-regression": [],
+    "image-to-image": [],
+    "tabular-to-text": [],
+    "unconditional-image-generation": [],
+    "text-retrieval": [],
+    "text-to-speech": [],
+    "object-detection": [],
+    "audio-to-audio": [],
+    "text-generation": [],
+    "conversational": [],
+    "table-question-answering": [],
+    "visual-question-answering": [],
+    "image-to-text": [],
+    "reinforcement-learning": [],
+    "voice-activity-detection": [],
+    "time-series-forecasting": [],
+    "document-question-answering": [],
+}
+
+
+if __name__ == "__main__":
+    from argparse import ArgumentParser
+
+    ap = ArgumentParser(usage="Validate the yaml metadata block of a README.md file.")
+    ap.add_argument("readme_filepath")
+    args = ap.parse_args()
+
+    readme_filepath = Path(args.readme_filepath)
+    dataset_metadata = DatasetMetadata.from_readme(readme_filepath)
+    print(dataset_metadata)
+    dataset_metadata.to_readme(readme_filepath)

venv/lib/python3.10/site-packages/datasets/utils/patching.py

@@ -0,0 +1,119 @@
+from importlib import import_module
+
+from .logging import get_logger
+
+
+logger = get_logger(__name__)
+
+
+class _PatchedModuleObj:
+    """Set all the modules components as attributes of the _PatchedModuleObj object."""
+
+    def __init__(self, module, attrs=None):
+        attrs = attrs or []
+        if module is not None:
+            for key in module.__dict__:
+                if key in attrs or not key.startswith("__"):
+                    setattr(self, key, getattr(module, key))
+        self._original_module = module._original_module if isinstance(module, _PatchedModuleObj) else module
+
+
+class patch_submodule:
+    """
+    Patch a submodule attribute of an object, by keeping all other submodules intact at all levels.
+
+    Example::
+
+        >>> import importlib
+        >>> from datasets.load import dataset_module_factory
+        >>> from datasets.streaming import patch_submodule, xjoin
+        >>>
+        >>> dataset_module = dataset_module_factory("snli")
+        >>> snli_module = importlib.import_module(dataset_module.module_path)
+        >>> patcher = patch_submodule(snli_module, "os.path.join", xjoin)
+        >>> patcher.start()
+        >>> assert snli_module.os.path.join is xjoin
+    """
+
+    _active_patches = []
+
+    def __init__(self, obj, target: str, new, attrs=None):
+        self.obj = obj
+        self.target = target
+        self.new = new
+        self.key = target.split(".")[0]
+        self.original = {}
+        self.attrs = attrs or []
+
+    def __enter__(self):
+        *submodules, target_attr = self.target.split(".")
+
+        # Patch modules:
+        # it's used to patch attributes of submodules like "os.path.join";
+        # in this case we need to patch "os" and "os.path"
+
+        for i in range(len(submodules)):
+            try:
+                submodule = import_module(".".join(submodules[: i + 1]))
+            except ModuleNotFoundError:
+                continue
+            # We iterate over all the globals in self.obj in case we find "os" or "os.path"
+            for attr in self.obj.__dir__():
+                obj_attr = getattr(self.obj, attr)
+                # We don't check for the name of the global, but rather if its value *is* "os" or "os.path".
+                # This allows to patch renamed modules like "from os import path as ospath".
+                if obj_attr is submodule or (
+                    isinstance(obj_attr, _PatchedModuleObj) and obj_attr._original_module is submodule
+                ):
+                    self.original[attr] = obj_attr
+                    # patch at top level
+                    setattr(self.obj, attr, _PatchedModuleObj(obj_attr, attrs=self.attrs))
+                    patched = getattr(self.obj, attr)
+                    # construct lower levels patches
+                    for key in submodules[i + 1 :]:
+                        setattr(patched, key, _PatchedModuleObj(getattr(patched, key, None), attrs=self.attrs))
+                        patched = getattr(patched, key)
+                    # finally set the target attribute
+                    setattr(patched, target_attr, self.new)
+
+        # Patch attribute itself:
+        # it's used for builtins like "open",
+        # and also to patch "os.path.join" we may also need to patch "join"
+        # itself if it was imported as "from os.path import join".
+
+        if submodules:  # if it's an attribute of a submodule like "os.path.join"
+            try:
+                attr_value = getattr(import_module(".".join(submodules)), target_attr)
+            except (AttributeError, ModuleNotFoundError):
+                return
+            # We iterate over all the globals in self.obj in case we find "os.path.join"
+            for attr in self.obj.__dir__():
+                # We don't check for the name of the global, but rather if its value *is* "os.path.join".
+                # This allows to patch renamed attributes like "from os.path import join as pjoin".
+                if getattr(self.obj, attr) is attr_value:
+                    self.original[attr] = getattr(self.obj, attr)
+                    setattr(self.obj, attr, self.new)
+        elif target_attr in globals()["__builtins__"]:  # if it'a s builtin like "open"
+            self.original[target_attr] = globals()["__builtins__"][target_attr]
+            setattr(self.obj, target_attr, self.new)
+        else:
+            raise RuntimeError(f"Tried to patch attribute {target_attr} instead of a submodule.")
+
+    def __exit__(self, *exc_info):
+        for attr in list(self.original):
+            setattr(self.obj, attr, self.original.pop(attr))
+
+    def start(self):
+        """Activate a patch."""
+        self.__enter__()
+        self._active_patches.append(self)
+
+    def stop(self):
+        """Stop an active patch."""
+        try:
+            self._active_patches.remove(self)
+        except ValueError:
+            # If the patch hasn't been started this will fail
+            return None
+
+        return self.__exit__()