Add files using upload-large-folder tool

.gitattributes

@@ -62,3 +62,5 @@ llmeval-env/bin/python3 filter=lfs diff=lfs merge=lfs -text
 llmeval-env/bin/python filter=lfs diff=lfs merge=lfs -text
 llmeval-env/lib/python3.10/site-packages/scipy/optimize/_highs/_highs_wrapper.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 llmeval-env/lib/python3.10/site-packages/scipy/sparse/_sparsetools.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+llmeval-env/lib/python3.10/site-packages/scipy/spatial/_ckdtree.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+llmeval-env/lib/python3.10/site-packages/scipy/spatial/_qhull.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

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

@@ -0,0 +1,20 @@
+# ruff: noqa
+
+__all__ = [
+    "Audio",
+    "Array2D",
+    "Array3D",
+    "Array4D",
+    "Array5D",
+    "ClassLabel",
+    "Features",
+    "Sequence",
+    "Value",
+    "Image",
+    "Translation",
+    "TranslationVariableLanguages",
+]
+from .audio import Audio
+from .features import Array2D, Array3D, Array4D, Array5D, ClassLabel, Features, Sequence, Value
+from .image import Image
+from .translation import Translation, TranslationVariableLanguages

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

@@ -0,0 +1,277 @@
+import os
+from dataclasses import dataclass, field
+from io import BytesIO
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, Optional, Union
+
+import numpy as np
+import pyarrow as pa
+
+from .. import config
+from ..download.download_config import DownloadConfig
+from ..table import array_cast
+from ..utils.file_utils import xopen, xsplitext
+from ..utils.py_utils import no_op_if_value_is_null, string_to_dict
+
+
+if TYPE_CHECKING:
+    from .features import FeatureType
+
+
+@dataclass
+class Audio:
+    """Audio [`Feature`] to extract audio data from an audio file.
+
+    Input: The Audio feature accepts as input:
+    - A `str`: Absolute path to the audio file (i.e. random access is allowed).
+    - A `dict` with the keys:
+
+        - `path`: String with relative path of the audio file to the archive file.
+        - `bytes`: Bytes content of the audio file.
+
+      This is useful for archived files with sequential access.
+
+    - A `dict` with the keys:
+
+        - `path`: String with relative path of the audio file to the archive file.
+        - `array`: Array containing the audio sample
+        - `sampling_rate`: Integer corresponding to the sampling rate of the audio sample.
+
+      This is useful for archived files with sequential access.
+
+    Args:
+        sampling_rate (`int`, *optional*):
+            Target sampling rate. If `None`, the native sampling rate is used.
+        mono (`bool`, defaults to `True`):
+            Whether to convert the audio signal to mono by averaging samples across
+            channels.
+        decode (`bool`, defaults to `True`):
+            Whether to decode the audio data. If `False`,
+            returns the underlying dictionary in the format `{"path": audio_path, "bytes": audio_bytes}`.
+
+    Example:
+
+    ```py
+    >>> from datasets import load_dataset, Audio
+    >>> ds = load_dataset("PolyAI/minds14", name="en-US", split="train")
+    >>> ds = ds.cast_column("audio", Audio(sampling_rate=16000))
+    >>> ds[0]["audio"]
+    {'array': array([ 2.3443763e-05,  2.1729663e-04,  2.2145823e-04, ...,
+         3.8356509e-05, -7.3497440e-06, -2.1754686e-05], dtype=float32),
+     'path': '/root/.cache/huggingface/datasets/downloads/extracted/f14948e0e84be638dd7943ac36518a4cf3324e8b7aa331c5ab11541518e9368c/en-US~JOINT_ACCOUNT/602ba55abb1e6d0fbce92065.wav',
+     'sampling_rate': 16000}
+    ```
+    """
+
+    sampling_rate: Optional[int] = None
+    mono: bool = True
+    decode: bool = True
+    id: Optional[str] = None
+    # Automatically constructed
+    dtype: ClassVar[str] = "dict"
+    pa_type: ClassVar[Any] = pa.struct({"bytes": pa.binary(), "path": pa.string()})
+    _type: str = field(default="Audio", init=False, repr=False)
+
+    def __call__(self):
+        return self.pa_type
+
+    def encode_example(self, value: Union[str, bytes, dict]) -> dict:
+        """Encode example into a format for Arrow.
+
+        Args:
+            value (`str` or `dict`):
+                Data passed as input to Audio feature.
+
+        Returns:
+            `dict`
+        """
+        try:
+            import soundfile as sf  # soundfile is a dependency of librosa, needed to decode audio files.
+        except ImportError as err:
+            raise ImportError("To support encoding audio data, please install 'soundfile'.") from err
+        if isinstance(value, str):
+            return {"bytes": None, "path": value}
+        elif isinstance(value, bytes):
+            return {"bytes": value, "path": None}
+        elif "array" in value:
+            # convert the audio array to wav bytes
+            buffer = BytesIO()
+            sf.write(buffer, value["array"], value["sampling_rate"], format="wav")
+            return {"bytes": buffer.getvalue(), "path": None}
+        elif value.get("path") is not None and os.path.isfile(value["path"]):
+            # we set "bytes": None to not duplicate the data if they're already available locally
+            if value["path"].endswith("pcm"):
+                # "PCM" only has raw audio bytes
+                if value.get("sampling_rate") is None:
+                    # At least, If you want to convert "PCM-byte" to "WAV-byte", you have to know sampling rate
+                    raise KeyError("To use PCM files, please specify a 'sampling_rate' in Audio object")
+                if value.get("bytes"):
+                    # If we already had PCM-byte, we don`t have to make "read file, make bytes" (just use it!)
+                    bytes_value = np.frombuffer(value["bytes"], dtype=np.int16).astype(np.float32) / 32767
+                else:
+                    bytes_value = np.memmap(value["path"], dtype="h", mode="r").astype(np.float32) / 32767
+
+                buffer = BytesIO(bytes())
+                sf.write(buffer, bytes_value, value["sampling_rate"], format="wav")
+                return {"bytes": buffer.getvalue(), "path": None}
+            else:
+                return {"bytes": None, "path": value.get("path")}
+        elif value.get("bytes") is not None or value.get("path") is not None:
+            # store the audio bytes, and path is used to infer the audio format using the file extension
+            return {"bytes": value.get("bytes"), "path": value.get("path")}
+        else:
+            raise ValueError(
+                f"An audio sample should have one of 'path' or 'bytes' but they are missing or None in {value}."
+            )
+
+    def decode_example(
+        self, value: dict, token_per_repo_id: Optional[Dict[str, Union[str, bool, None]]] = None
+    ) -> dict:
+        """Decode example audio file into audio data.
+
+        Args:
+            value (`dict`):
+                A dictionary with keys:
+
+                - `path`: String with relative audio file path.
+                - `bytes`: Bytes of the audio file.
+            token_per_repo_id (`dict`, *optional*):
+                To access and decode
+                audio files from private repositories on the Hub, you can pass
+                a dictionary repo_id (`str`) -> token (`bool` or `str`)
+
+        Returns:
+            `dict`
+        """
+        if not self.decode:
+            raise RuntimeError("Decoding is disabled for this feature. Please use Audio(decode=True) instead.")
+
+        path, file = (value["path"], BytesIO(value["bytes"])) if value["bytes"] is not None else (value["path"], None)
+        if path is None and file is None:
+            raise ValueError(f"An audio sample should have one of 'path' or 'bytes' but both are None in {value}.")
+
+        try:
+            import librosa
+            import soundfile as sf
+        except ImportError as err:
+            raise ImportError("To support decoding audio files, please install 'librosa' and 'soundfile'.") from err
+
+        audio_format = xsplitext(path)[1][1:].lower() if path is not None else None
+        if not config.IS_OPUS_SUPPORTED and audio_format == "opus":
+            raise RuntimeError(
+                "Decoding 'opus' files requires system library 'libsndfile'>=1.0.31, "
+                'You can try to update `soundfile` python library: `pip install "soundfile>=0.12.1"`. '
+            )
+        elif not config.IS_MP3_SUPPORTED and audio_format == "mp3":
+            raise RuntimeError(
+                "Decoding 'mp3' files requires system library 'libsndfile'>=1.1.0, "
+                'You can try to update `soundfile` python library: `pip install "soundfile>=0.12.1"`. '
+            )
+
+        if file is None:
+            token_per_repo_id = token_per_repo_id or {}
+            source_url = path.split("::")[-1]
+            pattern = (
+                config.HUB_DATASETS_URL if source_url.startswith(config.HF_ENDPOINT) else config.HUB_DATASETS_HFFS_URL
+            )
+            try:
+                repo_id = string_to_dict(source_url, pattern)["repo_id"]
+                token = token_per_repo_id[repo_id]
+            except (ValueError, KeyError):
+                token = None
+
+            download_config = DownloadConfig(token=token)
+            with xopen(path, "rb", download_config=download_config) as f:
+                array, sampling_rate = sf.read(f)
+
+        else:
+            array, sampling_rate = sf.read(file)
+
+        array = array.T
+        if self.mono:
+            array = librosa.to_mono(array)
+        if self.sampling_rate and self.sampling_rate != sampling_rate:
+            array = librosa.resample(array, orig_sr=sampling_rate, target_sr=self.sampling_rate)
+            sampling_rate = self.sampling_rate
+
+        return {"path": path, "array": array, "sampling_rate": sampling_rate}
+
+    def flatten(self) -> Union["FeatureType", Dict[str, "FeatureType"]]:
+        """If in the decodable state, raise an error, otherwise flatten the feature into a dictionary."""
+        from .features import Value
+
+        if self.decode:
+            raise ValueError("Cannot flatten a decoded Audio feature.")
+        return {
+            "bytes": Value("binary"),
+            "path": Value("string"),
+        }
+
+    def cast_storage(self, storage: Union[pa.StringArray, pa.StructArray]) -> pa.StructArray:
+        """Cast an Arrow array to the Audio arrow storage type.
+        The Arrow types that can be converted to the Audio pyarrow storage type are:
+
+        - `pa.string()` - it must contain the "path" data
+        - `pa.binary()` - it must contain the audio bytes
+        - `pa.struct({"bytes": pa.binary()})`
+        - `pa.struct({"path": pa.string()})`
+        - `pa.struct({"bytes": pa.binary(), "path": pa.string()})`  - order doesn't matter
+
+        Args:
+            storage (`Union[pa.StringArray, pa.StructArray]`):
+                PyArrow array to cast.
+
+        Returns:
+            `pa.StructArray`: Array in the Audio arrow storage type, that is
+                `pa.struct({"bytes": pa.binary(), "path": pa.string()})`
+        """
+        if pa.types.is_string(storage.type):
+            bytes_array = pa.array([None] * len(storage), type=pa.binary())
+            storage = pa.StructArray.from_arrays([bytes_array, storage], ["bytes", "path"], mask=storage.is_null())
+        elif pa.types.is_binary(storage.type):
+            path_array = pa.array([None] * len(storage), type=pa.string())
+            storage = pa.StructArray.from_arrays([storage, path_array], ["bytes", "path"], mask=storage.is_null())
+        elif pa.types.is_struct(storage.type) and storage.type.get_all_field_indices("array"):
+            storage = pa.array([Audio().encode_example(x) if x is not None else None for x in storage.to_pylist()])
+        elif pa.types.is_struct(storage.type):
+            if storage.type.get_field_index("bytes") >= 0:
+                bytes_array = storage.field("bytes")
+            else:
+                bytes_array = pa.array([None] * len(storage), type=pa.binary())
+            if storage.type.get_field_index("path") >= 0:
+                path_array = storage.field("path")
+            else:
+                path_array = pa.array([None] * len(storage), type=pa.string())
+            storage = pa.StructArray.from_arrays([bytes_array, path_array], ["bytes", "path"], mask=storage.is_null())
+        return array_cast(storage, self.pa_type)
+
+    def embed_storage(self, storage: pa.StructArray) -> pa.StructArray:
+        """Embed audio files into the Arrow array.
+
+        Args:
+            storage (`pa.StructArray`):
+                PyArrow array to embed.
+
+        Returns:
+            `pa.StructArray`: Array in the Audio arrow storage type, that is
+                `pa.struct({"bytes": pa.binary(), "path": pa.string()})`.
+        """
+
+        @no_op_if_value_is_null
+        def path_to_bytes(path):
+            with xopen(path, "rb") as f:
+                bytes_ = f.read()
+            return bytes_
+
+        bytes_array = pa.array(
+            [
+                (path_to_bytes(x["path"]) if x["bytes"] is None else x["bytes"]) if x is not None else None
+                for x in storage.to_pylist()
+            ],
+            type=pa.binary(),
+        )
+        path_array = pa.array(
+            [os.path.basename(path) if path is not None else None for path in storage.field("path").to_pylist()],
+            type=pa.string(),
+        )
+        storage = pa.StructArray.from_arrays([bytes_array, path_array], ["bytes", "path"], mask=bytes_array.is_null())
+        return array_cast(storage, self.pa_type)

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

@@ -0,0 +1,2202 @@
+# Copyright 2020 The HuggingFace Datasets Authors and the TensorFlow Datasets Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Lint as: python3
+"""This class handle features definition in datasets and some utilities to display table type."""
+
+import copy
+import json
+import re
+import sys
+from collections.abc import Iterable, Mapping
+from collections.abc import Sequence as SequenceABC
+from dataclasses import InitVar, dataclass, field, fields
+from functools import reduce, wraps
+from operator import mul
+from typing import Any, Callable, ClassVar, Dict, List, Optional, Tuple, Union
+from typing import Sequence as Sequence_
+
+import numpy as np
+import pandas as pd
+import pyarrow as pa
+import pyarrow.compute as pc
+import pyarrow.types
+import pyarrow_hotfix  # noqa: F401  # to fix vulnerability on pyarrow<14.0.1
+from pandas.api.extensions import ExtensionArray as PandasExtensionArray
+from pandas.api.extensions import ExtensionDtype as PandasExtensionDtype
+
+from .. import config
+from ..naming import camelcase_to_snakecase, snakecase_to_camelcase
+from ..table import array_cast
+from ..utils import experimental, logging
+from ..utils.py_utils import asdict, first_non_null_value, zip_dict
+from .audio import Audio
+from .image import Image, encode_pil_image
+from .translation import Translation, TranslationVariableLanguages
+
+
+logger = logging.get_logger(__name__)
+
+
+def _arrow_to_datasets_dtype(arrow_type: pa.DataType) -> str:
+    """
+    _arrow_to_datasets_dtype takes a pyarrow.DataType and converts it to a datasets string dtype.
+    In effect, `dt == string_to_arrow(_arrow_to_datasets_dtype(dt))`
+    """
+    if pyarrow.types.is_null(arrow_type):
+        return "null"
+    elif pyarrow.types.is_boolean(arrow_type):
+        return "bool"
+    elif pyarrow.types.is_int8(arrow_type):
+        return "int8"
+    elif pyarrow.types.is_int16(arrow_type):
+        return "int16"
+    elif pyarrow.types.is_int32(arrow_type):
+        return "int32"
+    elif pyarrow.types.is_int64(arrow_type):
+        return "int64"
+    elif pyarrow.types.is_uint8(arrow_type):
+        return "uint8"
+    elif pyarrow.types.is_uint16(arrow_type):
+        return "uint16"
+    elif pyarrow.types.is_uint32(arrow_type):
+        return "uint32"
+    elif pyarrow.types.is_uint64(arrow_type):
+        return "uint64"
+    elif pyarrow.types.is_float16(arrow_type):
+        return "float16"  # pyarrow dtype is "halffloat"
+    elif pyarrow.types.is_float32(arrow_type):
+        return "float32"  # pyarrow dtype is "float"
+    elif pyarrow.types.is_float64(arrow_type):
+        return "float64"  # pyarrow dtype is "double"
+    elif pyarrow.types.is_time32(arrow_type):
+        return f"time32[{pa.type_for_alias(str(arrow_type)).unit}]"
+    elif pyarrow.types.is_time64(arrow_type):
+        return f"time64[{pa.type_for_alias(str(arrow_type)).unit}]"
+    elif pyarrow.types.is_timestamp(arrow_type):
+        if arrow_type.tz is None:
+            return f"timestamp[{arrow_type.unit}]"
+        elif arrow_type.tz:
+            return f"timestamp[{arrow_type.unit}, tz={arrow_type.tz}]"
+        else:
+            raise ValueError(f"Unexpected timestamp object {arrow_type}.")
+    elif pyarrow.types.is_date32(arrow_type):
+        return "date32"  # pyarrow dtype is "date32[day]"
+    elif pyarrow.types.is_date64(arrow_type):
+        return "date64"  # pyarrow dtype is "date64[ms]"
+    elif pyarrow.types.is_duration(arrow_type):
+        return f"duration[{arrow_type.unit}]"
+    elif pyarrow.types.is_decimal128(arrow_type):
+        return f"decimal128({arrow_type.precision}, {arrow_type.scale})"
+    elif pyarrow.types.is_decimal256(arrow_type):
+        return f"decimal256({arrow_type.precision}, {arrow_type.scale})"
+    elif pyarrow.types.is_binary(arrow_type):
+        return "binary"
+    elif pyarrow.types.is_large_binary(arrow_type):
+        return "large_binary"
+    elif pyarrow.types.is_string(arrow_type):
+        return "string"
+    elif pyarrow.types.is_large_string(arrow_type):
+        return "large_string"
+    else:
+        raise ValueError(f"Arrow type {arrow_type} does not have a datasets dtype equivalent.")
+
+
+def string_to_arrow(datasets_dtype: str) -> pa.DataType:
+    """
+    string_to_arrow takes a datasets string dtype and converts it to a pyarrow.DataType.
+
+    In effect, `dt == string_to_arrow(_arrow_to_datasets_dtype(dt))`
+
+    This is necessary because the datasets.Value() primitive type is constructed using a string dtype
+
+    Value(dtype=str)
+
+    But Features.type (via `get_nested_type()` expects to resolve Features into a pyarrow Schema,
+        which means that each Value() must be able to resolve into a corresponding pyarrow.DataType, which is the
+        purpose of this function.
+    """
+
+    def _dtype_error_msg(dtype, pa_dtype, examples=None, urls=None):
+        msg = f"{dtype} is not a validly formatted string representation of the pyarrow {pa_dtype} type."
+        if examples:
+            examples = ", ".join(examples[:-1]) + " or " + examples[-1] if len(examples) > 1 else examples[0]
+            msg += f"\nValid examples include: {examples}."
+        if urls:
+            urls = ", ".join(urls[:-1]) + " and " + urls[-1] if len(urls) > 1 else urls[0]
+            msg += f"\nFor more insformation, see: {urls}."
+        return msg
+
+    if datasets_dtype in pa.__dict__:
+        return pa.__dict__[datasets_dtype]()
+
+    if (datasets_dtype + "_") in pa.__dict__:
+        return pa.__dict__[datasets_dtype + "_"]()
+
+    timestamp_matches = re.search(r"^timestamp\[(.*)\]$", datasets_dtype)
+    if timestamp_matches:
+        timestamp_internals = timestamp_matches.group(1)
+        internals_matches = re.search(r"^(s|ms|us|ns),\s*tz=([a-zA-Z0-9/_+\-:]*)$", timestamp_internals)
+        if timestamp_internals in ["s", "ms", "us", "ns"]:
+            return pa.timestamp(timestamp_internals)
+        elif internals_matches:
+            return pa.timestamp(internals_matches.group(1), internals_matches.group(2))
+        else:
+            raise ValueError(
+                _dtype_error_msg(
+                    datasets_dtype,
+                    "timestamp",
+                    examples=["timestamp[us]", "timestamp[us, tz=America/New_York"],
+                    urls=["https://arrow.apache.org/docs/python/generated/pyarrow.timestamp.html"],
+                )
+            )
+
+    duration_matches = re.search(r"^duration\[(.*)\]$", datasets_dtype)
+    if duration_matches:
+        duration_internals = duration_matches.group(1)
+        if duration_internals in ["s", "ms", "us", "ns"]:
+            return pa.duration(duration_internals)
+        else:
+            raise ValueError(
+                _dtype_error_msg(
+                    datasets_dtype,
+                    "duration",
+                    examples=["duration[s]", "duration[us]"],
+                    urls=["https://arrow.apache.org/docs/python/generated/pyarrow.duration.html"],
+                )
+            )
+
+    time_matches = re.search(r"^time(.*)\[(.*)\]$", datasets_dtype)
+    if time_matches:
+        time_internals_bits = time_matches.group(1)
+        if time_internals_bits == "32":
+            time_internals_unit = time_matches.group(2)
+            if time_internals_unit in ["s", "ms"]:
+                return pa.time32(time_internals_unit)
+            else:
+                raise ValueError(
+                    f"{time_internals_unit} is not a valid unit for the pyarrow time32 type. Supported units: s (second) and ms (millisecond)."
+                )
+        elif time_internals_bits == "64":
+            time_internals_unit = time_matches.group(2)
+            if time_internals_unit in ["us", "ns"]:
+                return pa.time64(time_internals_unit)
+            else:
+                raise ValueError(
+                    f"{time_internals_unit} is not a valid unit for the pyarrow time64 type. Supported units: us (microsecond) and ns (nanosecond)."
+                )
+        else:
+            raise ValueError(
+                _dtype_error_msg(
+                    datasets_dtype,
+                    "time",
+                    examples=["time32[s]", "time64[us]"],
+                    urls=[
+                        "https://arrow.apache.org/docs/python/generated/pyarrow.time32.html",
+                        "https://arrow.apache.org/docs/python/generated/pyarrow.time64.html",
+                    ],
+                )
+            )
+
+    decimal_matches = re.search(r"^decimal(.*)\((.*)\)$", datasets_dtype)
+    if decimal_matches:
+        decimal_internals_bits = decimal_matches.group(1)
+        if decimal_internals_bits == "128":
+            decimal_internals_precision_and_scale = re.search(r"^(\d+),\s*(-?\d+)$", decimal_matches.group(2))
+            if decimal_internals_precision_and_scale:
+                precision = decimal_internals_precision_and_scale.group(1)
+                scale = decimal_internals_precision_and_scale.group(2)
+                return pa.decimal128(int(precision), int(scale))
+            else:
+                raise ValueError(
+                    _dtype_error_msg(
+                        datasets_dtype,
+                        "decimal128",
+                        examples=["decimal128(10, 2)", "decimal128(4, -2)"],
+                        urls=["https://arrow.apache.org/docs/python/generated/pyarrow.decimal128.html"],
+                    )
+                )
+        elif decimal_internals_bits == "256":
+            decimal_internals_precision_and_scale = re.search(r"^(\d+),\s*(-?\d+)$", decimal_matches.group(2))
+            if decimal_internals_precision_and_scale:
+                precision = decimal_internals_precision_and_scale.group(1)
+                scale = decimal_internals_precision_and_scale.group(2)
+                return pa.decimal256(int(precision), int(scale))
+            else:
+                raise ValueError(
+                    _dtype_error_msg(
+                        datasets_dtype,
+                        "decimal256",
+                        examples=["decimal256(30, 2)", "decimal256(38, -4)"],
+                        urls=["https://arrow.apache.org/docs/python/generated/pyarrow.decimal256.html"],
+                    )
+                )
+        else:
+            raise ValueError(
+                _dtype_error_msg(
+                    datasets_dtype,
+                    "decimal",
+                    examples=["decimal128(12, 3)", "decimal256(40, 6)"],
+                    urls=[
+                        "https://arrow.apache.org/docs/python/generated/pyarrow.decimal128.html",
+                        "https://arrow.apache.org/docs/python/generated/pyarrow.decimal256.html",
+                    ],
+                )
+            )
+
+    raise ValueError(
+        f"Neither {datasets_dtype} nor {datasets_dtype + '_'} seems to be a pyarrow data type. "
+        f"Please make sure to use a correct data type, see: "
+        f"https://arrow.apache.org/docs/python/api/datatypes.html#factory-functions"
+    )
+
+
+def _cast_to_python_objects(obj: Any, only_1d_for_numpy: bool, optimize_list_casting: bool) -> Tuple[Any, bool]:
+    """
+    Cast pytorch/tensorflow/pandas objects to python numpy array/lists.
+    It works recursively.
+
+    If `optimize_list_casting` is True, to avoid iterating over possibly long lists, it first checks (recursively) if the first element that is not None or empty (if it is a sequence) has to be casted.
+    If the first element needs to be casted, then all the elements of the list will be casted, otherwise they'll stay the same.
+    This trick allows to cast objects that contain tokenizers outputs without iterating over every single token for example.
+
+    Args:
+        obj: the object (nested struct) to cast.
+        only_1d_for_numpy (bool): whether to keep the full multi-dim tensors as multi-dim numpy arrays, or convert them to
+            nested lists of 1-dimensional numpy arrays. This can be useful to keep only 1-d arrays to instantiate Arrow arrays.
+            Indeed Arrow only support converting 1-dimensional array values.
+        optimize_list_casting (bool): whether to optimize list casting by checking the first non-null element to see if it needs to be casted
+            and if it doesn't, not checking the rest of the list elements.
+
+    Returns:
+        casted_obj: the casted object
+        has_changed (bool): True if the object has been changed, False if it is identical
+    """
+
+    if config.TF_AVAILABLE and "tensorflow" in sys.modules:
+        import tensorflow as tf
+
+    if config.TORCH_AVAILABLE and "torch" in sys.modules:
+        import torch
+
+    if config.JAX_AVAILABLE and "jax" in sys.modules:
+        import jax.numpy as jnp
+
+    if config.PIL_AVAILABLE and "PIL" in sys.modules:
+        import PIL.Image
+
+    if isinstance(obj, np.ndarray):
+        if obj.ndim == 0:
+            return obj[()], True
+        elif not only_1d_for_numpy or obj.ndim == 1:
+            return obj, False
+        else:
+            return (
+                [
+                    _cast_to_python_objects(
+                        x, only_1d_for_numpy=only_1d_for_numpy, optimize_list_casting=optimize_list_casting
+                    )[0]
+                    for x in obj
+                ],
+                True,
+            )
+    elif config.TORCH_AVAILABLE and "torch" in sys.modules and isinstance(obj, torch.Tensor):
+        if obj.ndim == 0:
+            return obj.detach().cpu().numpy()[()], True
+        elif not only_1d_for_numpy or obj.ndim == 1:
+            return obj.detach().cpu().numpy(), True
+        else:
+            return (
+                [
+                    _cast_to_python_objects(
+                        x, only_1d_for_numpy=only_1d_for_numpy, optimize_list_casting=optimize_list_casting
+                    )[0]
+                    for x in obj.detach().cpu().numpy()
+                ],
+                True,
+            )
+    elif config.TF_AVAILABLE and "tensorflow" in sys.modules and isinstance(obj, tf.Tensor):
+        if obj.ndim == 0:
+            return obj.numpy()[()], True
+        elif not only_1d_for_numpy or obj.ndim == 1:
+            return obj.numpy(), True
+        else:
+            return (
+                [
+                    _cast_to_python_objects(
+                        x, only_1d_for_numpy=only_1d_for_numpy, optimize_list_casting=optimize_list_casting
+                    )[0]
+                    for x in obj.numpy()
+                ],
+                True,
+            )
+    elif config.JAX_AVAILABLE and "jax" in sys.modules and isinstance(obj, jnp.ndarray):
+        if obj.ndim == 0:
+            return np.asarray(obj)[()], True
+        elif not only_1d_for_numpy or obj.ndim == 1:
+            return np.asarray(obj), True
+        else:
+            return (
+                [
+                    _cast_to_python_objects(
+                        x, only_1d_for_numpy=only_1d_for_numpy, optimize_list_casting=optimize_list_casting
+                    )[0]
+                    for x in np.asarray(obj)
+                ],
+                True,
+            )
+    elif config.PIL_AVAILABLE and "PIL" in sys.modules and isinstance(obj, PIL.Image.Image):
+        return encode_pil_image(obj), True
+    elif isinstance(obj, pd.Series):
+        return (
+            _cast_to_python_objects(
+                obj.tolist(), only_1d_for_numpy=only_1d_for_numpy, optimize_list_casting=optimize_list_casting
+            )[0],
+            True,
+        )
+    elif isinstance(obj, pd.DataFrame):
+        return (
+            {
+                key: _cast_to_python_objects(
+                    value, only_1d_for_numpy=only_1d_for_numpy, optimize_list_casting=optimize_list_casting
+                )[0]
+                for key, value in obj.to_dict("series").items()
+            },
+            True,
+        )
+    elif isinstance(obj, pd.Timestamp):
+        return obj.to_pydatetime(), True
+    elif isinstance(obj, pd.Timedelta):
+        return obj.to_pytimedelta(), True
+    elif isinstance(obj, Mapping):
+        has_changed = not isinstance(obj, dict)
+        output = {}
+        for k, v in obj.items():
+            casted_v, has_changed_v = _cast_to_python_objects(
+                v, only_1d_for_numpy=only_1d_for_numpy, optimize_list_casting=optimize_list_casting
+            )
+            has_changed |= has_changed_v
+            output[k] = casted_v
+        return output if has_changed else obj, has_changed
+    elif hasattr(obj, "__array__"):
+        return (
+            _cast_to_python_objects(
+                obj.__array__(), only_1d_for_numpy=only_1d_for_numpy, optimize_list_casting=optimize_list_casting
+            )[0],
+            True,
+        )
+    elif isinstance(obj, (list, tuple)):
+        if len(obj) > 0:
+            for first_elmt in obj:
+                if _check_non_null_non_empty_recursive(first_elmt):
+                    break
+            casted_first_elmt, has_changed_first_elmt = _cast_to_python_objects(
+                first_elmt, only_1d_for_numpy=only_1d_for_numpy, optimize_list_casting=optimize_list_casting
+            )
+            if has_changed_first_elmt or not optimize_list_casting:
+                return (
+                    [
+                        _cast_to_python_objects(
+                            elmt, only_1d_for_numpy=only_1d_for_numpy, optimize_list_casting=optimize_list_casting
+                        )[0]
+                        for elmt in obj
+                    ],
+                    True,
+                )
+            else:
+                if isinstance(obj, (list, tuple)):
+                    return obj, False
+                else:
+                    return list(obj), True
+        else:
+            return obj, False
+    else:
+        return obj, False
+
+
+def cast_to_python_objects(obj: Any, only_1d_for_numpy=False, optimize_list_casting=True) -> Any:
+    """
+    Cast numpy/pytorch/tensorflow/pandas objects to python lists.
+    It works recursively.
+
+    If `optimize_list_casting` is True, To avoid iterating over possibly long lists, it first checks (recursively) if the first element that is not None or empty (if it is a sequence) has to be casted.
+    If the first element needs to be casted, then all the elements of the list will be casted, otherwise they'll stay the same.
+    This trick allows to cast objects that contain tokenizers outputs without iterating over every single token for example.
+
+    Args:
+        obj: the object (nested struct) to cast
+        only_1d_for_numpy (bool, default ``False``): whether to keep the full multi-dim tensors as multi-dim numpy arrays, or convert them to
+            nested lists of 1-dimensional numpy arrays. This can be useful to keep only 1-d arrays to instantiate Arrow arrays.
+            Indeed Arrow only support converting 1-dimensional array values.
+        optimize_list_casting (bool, default ``True``): whether to optimize list casting by checking the first non-null element to see if it needs to be casted
+            and if it doesn't, not checking the rest of the list elements.
+
+    Returns:
+        casted_obj: the casted object
+    """
+    return _cast_to_python_objects(
+        obj, only_1d_for_numpy=only_1d_for_numpy, optimize_list_casting=optimize_list_casting
+    )[0]
+
+
+@dataclass
+class Value:
+    """
+    The `Value` dtypes are as follows:
+
+    - `null`
+    - `bool`
+    - `int8`
+    - `int16`
+    - `int32`
+    - `int64`
+    - `uint8`
+    - `uint16`
+    - `uint32`
+    - `uint64`
+    - `float16`
+    - `float32` (alias float)
+    - `float64` (alias double)
+    - `time32[(s|ms)]`
+    - `time64[(us|ns)]`
+    - `timestamp[(s|ms|us|ns)]`
+    - `timestamp[(s|ms|us|ns), tz=(tzstring)]`
+    - `date32`
+    - `date64`
+    - `duration[(s|ms|us|ns)]`
+    - `decimal128(precision, scale)`
+    - `decimal256(precision, scale)`
+    - `binary`
+    - `large_binary`
+    - `string`
+    - `large_string`
+
+    Example:
+
+    ```py
+    >>> from datasets import Features
+    >>> features = Features({'stars': Value(dtype='int32')})
+    >>> features
+    {'stars': Value(dtype='int32', id=None)}
+    ```
+    """
+
+    dtype: str
+    id: Optional[str] = None
+    # Automatically constructed
+    pa_type: ClassVar[Any] = None
+    _type: str = field(default="Value", init=False, repr=False)
+
+    def __post_init__(self):
+        if self.dtype == "double":  # fix inferred type
+            self.dtype = "float64"
+        if self.dtype == "float":  # fix inferred type
+            self.dtype = "float32"
+        self.pa_type = string_to_arrow(self.dtype)
+
+    def __call__(self):
+        return self.pa_type
+
+    def encode_example(self, value):
+        if pa.types.is_boolean(self.pa_type):
+            return bool(value)
+        elif pa.types.is_integer(self.pa_type):
+            return int(value)
+        elif pa.types.is_floating(self.pa_type):
+            return float(value)
+        elif pa.types.is_string(self.pa_type):
+            return str(value)
+        else:
+            return value
+
+
+class _ArrayXD:
+    def __post_init__(self):
+        self.shape = tuple(self.shape)
+
+    def __call__(self):
+        pa_type = globals()[self.__class__.__name__ + "ExtensionType"](self.shape, self.dtype)
+        return pa_type
+
+    def encode_example(self, value):
+        return value
+
+
+@dataclass
+class Array2D(_ArrayXD):
+    """Create a two-dimensional array.
+
+    Args:
+        shape (`tuple`):
+            The size of each dimension.
+        dtype (`str`):
+            The value of the data type.
+
+    Example:
+
+    ```py
+    >>> from datasets import Features
+    >>> features = Features({'x': Array2D(shape=(1, 3), dtype='int32')})
+    ```
+    """
+
+    shape: tuple
+    dtype: str
+    id: Optional[str] = None
+    # Automatically constructed
+    _type: str = field(default="Array2D", init=False, repr=False)
+
+
+@dataclass
+class Array3D(_ArrayXD):
+    """Create a three-dimensional array.
+
+    Args:
+        shape (`tuple`):
+            The size of each dimension.
+        dtype (`str`):
+            The value of the data type.
+
+    Example:
+
+    ```py
+    >>> from datasets import Features
+    >>> features = Features({'x': Array3D(shape=(1, 2, 3), dtype='int32')})
+    ```
+    """
+
+    shape: tuple
+    dtype: str
+    id: Optional[str] = None
+    # Automatically constructed
+    _type: str = field(default="Array3D", init=False, repr=False)
+
+
+@dataclass
+class Array4D(_ArrayXD):
+    """Create a four-dimensional array.
+
+    Args:
+        shape (`tuple`):
+            The size of each dimension.
+        dtype (`str`):
+            The value of the data type.
+
+    Example:
+
+    ```py
+    >>> from datasets import Features
+    >>> features = Features({'x': Array4D(shape=(1, 2, 2, 3), dtype='int32')})
+    ```
+    """
+
+    shape: tuple
+    dtype: str
+    id: Optional[str] = None
+    # Automatically constructed
+    _type: str = field(default="Array4D", init=False, repr=False)
+
+
+@dataclass
+class Array5D(_ArrayXD):
+    """Create a five-dimensional array.
+
+    Args:
+        shape (`tuple`):
+            The size of each dimension.
+        dtype (`str`):
+            The value of the data type.
+
+    Example:
+
+    ```py
+    >>> from datasets import Features
+    >>> features = Features({'x': Array5D(shape=(1, 2, 2, 3, 3), dtype='int32')})
+    ```
+    """
+
+    shape: tuple
+    dtype: str
+    id: Optional[str] = None
+    # Automatically constructed
+    _type: str = field(default="Array5D", init=False, repr=False)
+
+
+class _ArrayXDExtensionType(pa.ExtensionType):
+    ndims: Optional[int] = None
+
+    def __init__(self, shape: tuple, dtype: str):
+        if self.ndims is None or self.ndims <= 1:
+            raise ValueError("You must instantiate an array type with a value for dim that is > 1")
+        if len(shape) != self.ndims:
+            raise ValueError(f"shape={shape} and ndims={self.ndims} don't match")
+        for dim in range(1, self.ndims):
+            if shape[dim] is None:
+                raise ValueError(f"Support only dynamic size on first dimension. Got: {shape}")
+        self.shape = tuple(shape)
+        self.value_type = dtype
+        self.storage_dtype = self._generate_dtype(self.value_type)
+        pa.ExtensionType.__init__(self, self.storage_dtype, f"{self.__class__.__module__}.{self.__class__.__name__}")
+
+    def __arrow_ext_serialize__(self):
+        return json.dumps((self.shape, self.value_type)).encode()
+
+    @classmethod
+    def __arrow_ext_deserialize__(cls, storage_type, serialized):
+        args = json.loads(serialized)
+        return cls(*args)
+
+    # This was added to pa.ExtensionType in pyarrow >= 13.0.0
+    def __reduce__(self):
+        return self.__arrow_ext_deserialize__, (self.storage_type, self.__arrow_ext_serialize__())
+
+    def __hash__(self):
+        return hash((self.__class__, self.shape, self.value_type))
+
+    def __arrow_ext_class__(self):
+        return ArrayExtensionArray
+
+    def _generate_dtype(self, dtype):
+        dtype = string_to_arrow(dtype)
+        for d in reversed(self.shape):
+            dtype = pa.list_(dtype)
+            # Don't specify the size of the list, since fixed length list arrays have issues
+            # being validated after slicing in pyarrow 0.17.1
+        return dtype
+
+    def to_pandas_dtype(self):
+        return PandasArrayExtensionDtype(self.value_type)
+
+
+class Array2DExtensionType(_ArrayXDExtensionType):
+    ndims = 2
+
+
+class Array3DExtensionType(_ArrayXDExtensionType):
+    ndims = 3
+
+
+class Array4DExtensionType(_ArrayXDExtensionType):
+    ndims = 4
+
+
+class Array5DExtensionType(_ArrayXDExtensionType):
+    ndims = 5
+
+
+# Register the extension types for deserialization
+pa.register_extension_type(Array2DExtensionType((1, 2), "int64"))
+pa.register_extension_type(Array3DExtensionType((1, 2, 3), "int64"))
+pa.register_extension_type(Array4DExtensionType((1, 2, 3, 4), "int64"))
+pa.register_extension_type(Array5DExtensionType((1, 2, 3, 4, 5), "int64"))
+
+
+def _is_zero_copy_only(pa_type: pa.DataType, unnest: bool = False) -> bool:
+    """
+    When converting a pyarrow array to a numpy array, we must know whether this could be done in zero-copy or not.
+    This function returns the value of the ``zero_copy_only`` parameter to pass to ``.to_numpy()``, given the type of the pyarrow array.
+
+    # zero copy is available for all primitive types except booleans and temporal types (date, time, timestamp or duration)
+    # primitive types are types for which the physical representation in arrow and in numpy
+    # https://github.com/wesm/arrow/blob/c07b9b48cf3e0bbbab493992a492ae47e5b04cad/python/pyarrow/types.pxi#L821
+    # see https://arrow.apache.org/docs/python/generated/pyarrow.Array.html#pyarrow.Array.to_numpy
+    # and https://issues.apache.org/jira/browse/ARROW-2871?jql=text%20~%20%22boolean%20to_numpy%22
+    """
+
+    def _unnest_pa_type(pa_type: pa.DataType) -> pa.DataType:
+        if pa.types.is_list(pa_type):
+            return _unnest_pa_type(pa_type.value_type)
+        return pa_type
+
+    if unnest:
+        pa_type = _unnest_pa_type(pa_type)
+    return pa.types.is_primitive(pa_type) and not (pa.types.is_boolean(pa_type) or pa.types.is_temporal(pa_type))
+
+
+class ArrayExtensionArray(pa.ExtensionArray):
+    def __array__(self):
+        zero_copy_only = _is_zero_copy_only(self.storage.type, unnest=True)
+        return self.to_numpy(zero_copy_only=zero_copy_only)
+
+    def __getitem__(self, i):
+        return self.storage[i]
+
+    def to_numpy(self, zero_copy_only=True):
+        storage: pa.ListArray = self.storage
+        null_mask = storage.is_null().to_numpy(zero_copy_only=False)
+
+        if self.type.shape[0] is not None:
+            size = 1
+            null_indices = np.arange(len(storage))[null_mask] - np.arange(np.sum(null_mask))
+
+            for i in range(self.type.ndims):
+                size *= self.type.shape[i]
+                storage = storage.flatten()
+            numpy_arr = storage.to_numpy(zero_copy_only=zero_copy_only)
+            numpy_arr = numpy_arr.reshape(len(self) - len(null_indices), *self.type.shape)
+
+            if len(null_indices):
+                numpy_arr = np.insert(numpy_arr.astype(np.float64), null_indices, np.nan, axis=0)
+
+        else:
+            shape = self.type.shape
+            ndims = self.type.ndims
+            arrays = []
+            first_dim_offsets = np.array([off.as_py() for off in storage.offsets])
+            for i, is_null in enumerate(null_mask):
+                if is_null:
+                    arrays.append(np.nan)
+                else:
+                    storage_el = storage[i : i + 1]
+                    first_dim = first_dim_offsets[i + 1] - first_dim_offsets[i]
+                    # flatten storage
+                    for _ in range(ndims):
+                        storage_el = storage_el.flatten()
+
+                    numpy_arr = storage_el.to_numpy(zero_copy_only=zero_copy_only)
+                    arrays.append(numpy_arr.reshape(first_dim, *shape[1:]))
+
+            if len(np.unique(np.diff(first_dim_offsets))) > 1:
+                # ragged
+                numpy_arr = np.empty(len(arrays), dtype=object)
+                numpy_arr[:] = arrays
+            else:
+                numpy_arr = np.array(arrays)
+
+        return numpy_arr
+
+    def to_pylist(self):
+        zero_copy_only = _is_zero_copy_only(self.storage.type, unnest=True)
+        numpy_arr = self.to_numpy(zero_copy_only=zero_copy_only)
+        if self.type.shape[0] is None and numpy_arr.dtype == object:
+            return [arr.tolist() for arr in numpy_arr.tolist()]
+        else:
+            return numpy_arr.tolist()
+
+
+class PandasArrayExtensionDtype(PandasExtensionDtype):
+    _metadata = "value_type"
+
+    def __init__(self, value_type: Union["PandasArrayExtensionDtype", np.dtype]):
+        self._value_type = value_type
+
+    def __from_arrow__(self, array: Union[pa.Array, pa.ChunkedArray]):
+        if isinstance(array, pa.ChunkedArray):
+            array = array.type.wrap_array(pa.concat_arrays([chunk.storage for chunk in array.chunks]))
+        zero_copy_only = _is_zero_copy_only(array.storage.type, unnest=True)
+        numpy_arr = array.to_numpy(zero_copy_only=zero_copy_only)
+        return PandasArrayExtensionArray(numpy_arr)
+
+    @classmethod
+    def construct_array_type(cls):
+        return PandasArrayExtensionArray
+
+    @property
+    def type(self) -> type:
+        return np.ndarray
+
+    @property
+    def kind(self) -> str:
+        return "O"
+
+    @property
+    def name(self) -> str:
+        return f"array[{self.value_type}]"
+
+    @property
+    def value_type(self) -> np.dtype:
+        return self._value_type
+
+
+class PandasArrayExtensionArray(PandasExtensionArray):
+    def __init__(self, data: np.ndarray, copy: bool = False):
+        self._data = data if not copy else np.array(data)
+        self._dtype = PandasArrayExtensionDtype(data.dtype)
+
+    def __array__(self, dtype=None):
+        """
+        Convert to NumPy Array.
+        Note that Pandas expects a 1D array when dtype is set to object.
+        But for other dtypes, the returned shape is the same as the one of ``data``.
+
+        More info about pandas 1D requirement for PandasExtensionArray here:
+        https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.api.extensions.ExtensionArray.html#pandas.api.extensions.ExtensionArray
+
+        """
+        if dtype == object:
+            out = np.empty(len(self._data), dtype=object)
+            for i in range(len(self._data)):
+                out[i] = self._data[i]
+            return out
+        if dtype is None:
+            return self._data
+        else:
+            return self._data.astype(dtype)
+
+    def copy(self, deep: bool = False) -> "PandasArrayExtensionArray":
+        return PandasArrayExtensionArray(self._data, copy=True)
+
+    @classmethod
+    def _from_sequence(
+        cls, scalars, dtype: Optional[PandasArrayExtensionDtype] = None, copy: bool = False
+    ) -> "PandasArrayExtensionArray":
+        if len(scalars) > 1 and all(
+            isinstance(x, np.ndarray) and x.shape == scalars[0].shape and x.dtype == scalars[0].dtype for x in scalars
+        ):
+            data = np.array(scalars, dtype=dtype if dtype is None else dtype.value_type, copy=copy)
+        else:
+            data = np.empty(len(scalars), dtype=object)
+            data[:] = scalars
+        return cls(data, copy=copy)
+
+    @classmethod
+    def _concat_same_type(cls, to_concat: Sequence_["PandasArrayExtensionArray"]) -> "PandasArrayExtensionArray":
+        if len(to_concat) > 1 and all(
+            va._data.shape == to_concat[0]._data.shape and va._data.dtype == to_concat[0]._data.dtype
+            for va in to_concat
+        ):
+            data = np.vstack([va._data for va in to_concat])
+        else:
+            data = np.empty(len(to_concat), dtype=object)
+            data[:] = [va._data for va in to_concat]
+        return cls(data, copy=False)
+
+    @property
+    def dtype(self) -> PandasArrayExtensionDtype:
+        return self._dtype
+
+    @property
+    def nbytes(self) -> int:
+        return self._data.nbytes
+
+    def isna(self) -> np.ndarray:
+        return np.array([pd.isna(arr).any() for arr in self._data])
+
+    def __setitem__(self, key: Union[int, slice, np.ndarray], value: Any) -> None:
+        raise NotImplementedError()
+
+    def __getitem__(self, item: Union[int, slice, np.ndarray]) -> Union[np.ndarray, "PandasArrayExtensionArray"]:
+        if isinstance(item, int):
+            return self._data[item]
+        return PandasArrayExtensionArray(self._data[item], copy=False)
+
+    def take(
+        self, indices: Sequence_[int], allow_fill: bool = False, fill_value: bool = None
+    ) -> "PandasArrayExtensionArray":
+        indices: np.ndarray = np.asarray(indices, dtype=int)
+        if allow_fill:
+            fill_value = (
+                self.dtype.na_value if fill_value is None else np.asarray(fill_value, dtype=self.dtype.value_type)
+            )
+            mask = indices == -1
+            if (indices < -1).any():
+                raise ValueError("Invalid value in `indices`, must be all >= -1 for `allow_fill` is True")
+            elif len(self) > 0:
+                pass
+            elif not np.all(mask):
+                raise IndexError("Invalid take for empty PandasArrayExtensionArray, must be all -1.")
+            else:
+                data = np.array([fill_value] * len(indices), dtype=self.dtype.value_type)
+                return PandasArrayExtensionArray(data, copy=False)
+        took = self._data.take(indices, axis=0)
+        if allow_fill and mask.any():
+            took[mask] = [fill_value] * np.sum(mask)
+        return PandasArrayExtensionArray(took, copy=False)
+
+    def __len__(self) -> int:
+        return len(self._data)
+
+    def __eq__(self, other) -> np.ndarray:
+        if not isinstance(other, PandasArrayExtensionArray):
+            raise NotImplementedError(f"Invalid type to compare to: {type(other)}")
+        return (self._data == other._data).all()
+
+
+def pandas_types_mapper(dtype):
+    if isinstance(dtype, _ArrayXDExtensionType):
+        return PandasArrayExtensionDtype(dtype.value_type)
+
+
+@dataclass
+class ClassLabel:
+    """Feature type for integer class labels.
+
+    There are 3 ways to define a `ClassLabel`, which correspond to the 3 arguments:
+
+     * `num_classes`: Create 0 to (num_classes-1) labels.
+     * `names`: List of label strings.
+     * `names_file`: File containing the list of labels.
+
+    Under the hood the labels are stored as integers.
+    You can use negative integers to represent unknown/missing labels.
+
+    Args:
+        num_classes (`int`, *optional*):
+            Number of classes. All labels must be < `num_classes`.
+        names (`list` of `str`, *optional*):
+            String names for the integer classes.
+            The order in which the names are provided is kept.
+        names_file (`str`, *optional*):
+            Path to a file with names for the integer classes, one per line.
+
+    Example:
+
+    ```py
+    >>> from datasets import Features
+    >>> features = Features({'label': ClassLabel(num_classes=3, names=['bad', 'ok', 'good'])})
+    >>> features
+    {'label': ClassLabel(num_classes=3, names=['bad', 'ok', 'good'], id=None)}
+    ```
+    """
+
+    num_classes: InitVar[Optional[int]] = None  # Pseudo-field: ignored by asdict/fields when converting to/from dict
+    names: List[str] = None
+    names_file: InitVar[Optional[str]] = None  # Pseudo-field: ignored by asdict/fields when converting to/from dict
+    id: Optional[str] = None
+    # Automatically constructed
+    dtype: ClassVar[str] = "int64"
+    pa_type: ClassVar[Any] = pa.int64()
+    _str2int: ClassVar[Dict[str, int]] = None
+    _int2str: ClassVar[Dict[int, int]] = None
+    _type: str = field(default="ClassLabel", init=False, repr=False)
+
+    def __post_init__(self, num_classes, names_file):
+        self.num_classes = num_classes
+        self.names_file = names_file
+        if self.names_file is not None and self.names is not None:
+            raise ValueError("Please provide either names or names_file but not both.")
+        # Set self.names
+        if self.names is None:
+            if self.names_file is not None:
+                self.names = self._load_names_from_file(self.names_file)
+            elif self.num_classes is not None:
+                self.names = [str(i) for i in range(self.num_classes)]
+            else:
+                raise ValueError("Please provide either num_classes, names or names_file.")
+        elif not isinstance(self.names, SequenceABC):
+            raise TypeError(f"Please provide names as a list, is {type(self.names)}")
+        # Set self.num_classes
+        if self.num_classes is None:
+            self.num_classes = len(self.names)
+        elif self.num_classes != len(self.names):
+            raise ValueError(
+                "ClassLabel number of names do not match the defined num_classes. "
+                f"Got {len(self.names)} names VS {self.num_classes} num_classes"
+            )
+        # Prepare mappings
+        self._int2str = [str(name) for name in self.names]
+        self._str2int = {name: i for i, name in enumerate(self._int2str)}
+        if len(self._int2str) != len(self._str2int):
+            raise ValueError("Some label names are duplicated. Each label name should be unique.")
+
+    def __call__(self):
+        return self.pa_type
+
+    def str2int(self, values: Union[str, Iterable]) -> Union[int, Iterable]:
+        """Conversion class name `string` => `integer`.
+
+        Example:
+
+        ```py
+        >>> from datasets import load_dataset
+        >>> ds = load_dataset("rotten_tomatoes", split="train")
+        >>> ds.features["label"].str2int('neg')
+        0
+        ```
+        """
+        if not isinstance(values, str) and not isinstance(values, Iterable):
+            raise ValueError(
+                f"Values {values} should be a string or an Iterable (list, numpy array, pytorch, tensorflow tensors)"
+            )
+        return_list = True
+        if isinstance(values, str):
+            values = [values]
+            return_list = False
+
+        output = [self._strval2int(value) for value in values]
+        return output if return_list else output[0]
+
+    def _strval2int(self, value: str) -> int:
+        failed_parse = False
+        value = str(value)
+        # first attempt - raw string value
+        int_value = self._str2int.get(value)
+        if int_value is None:
+            # second attempt - strip whitespace
+            int_value = self._str2int.get(value.strip())
+            if int_value is None:
+                # third attempt - convert str to int
+                try:
+                    int_value = int(value)
+                except ValueError:
+                    failed_parse = True
+                else:
+                    if int_value < -1 or int_value >= self.num_classes:
+                        failed_parse = True
+        if failed_parse:
+            raise ValueError(f"Invalid string class label {value}")
+        return int_value
+
+    def int2str(self, values: Union[int, Iterable]) -> Union[str, Iterable]:
+        """Conversion `integer` => class name `string`.
+
+        Regarding unknown/missing labels: passing negative integers raises `ValueError`.
+
+        Example:
+
+        ```py
+        >>> from datasets import load_dataset
+        >>> ds = load_dataset("rotten_tomatoes", split="train")
+        >>> ds.features["label"].int2str(0)
+        'neg'
+        ```
+        """
+        if not isinstance(values, int) and not isinstance(values, Iterable):
+            raise ValueError(
+                f"Values {values} should be an integer or an Iterable (list, numpy array, pytorch, tensorflow tensors)"
+            )
+        return_list = True
+        if isinstance(values, int):
+            values = [values]
+            return_list = False
+
+        for v in values:
+            if not 0 <= v < self.num_classes:
+                raise ValueError(f"Invalid integer class label {v:d}")
+
+        output = [self._int2str[int(v)] for v in values]
+        return output if return_list else output[0]
+
+    def encode_example(self, example_data):
+        if self.num_classes is None:
+            raise ValueError(
+                "Trying to use ClassLabel feature with undefined number of class. "
+                "Please set ClassLabel.names or num_classes."
+            )
+
+        # If a string is given, convert to associated integer
+        if isinstance(example_data, str):
+            example_data = self.str2int(example_data)
+
+        # Allowing -1 to mean no label.
+        if not -1 <= example_data < self.num_classes:
+            raise ValueError(f"Class label {example_data:d} greater than configured num_classes {self.num_classes}")
+        return example_data
+
+    def cast_storage(self, storage: Union[pa.StringArray, pa.IntegerArray]) -> pa.Int64Array:
+        """Cast an Arrow array to the `ClassLabel` arrow storage type.
+        The Arrow types that can be converted to the `ClassLabel` pyarrow storage type are:
+
+        - `pa.string()`
+        - `pa.int()`
+
+        Args:
+            storage (`Union[pa.StringArray, pa.IntegerArray]`):
+                PyArrow array to cast.
+
+        Returns:
+            `pa.Int64Array`: Array in the `ClassLabel` arrow storage type.
+        """
+        if isinstance(storage, pa.IntegerArray) and len(storage) > 0:
+            min_max = pc.min_max(storage).as_py()
+            if min_max["max"] is not None and min_max["max"] >= self.num_classes:
+                raise ValueError(
+                    f"Class label {min_max['max']} greater than configured num_classes {self.num_classes}"
+                )
+        elif isinstance(storage, pa.StringArray):
+            storage = pa.array(
+                [self._strval2int(label) if label is not None else None for label in storage.to_pylist()]
+            )
+        return array_cast(storage, self.pa_type)
+
+    @staticmethod
+    def _load_names_from_file(names_filepath):
+        with open(names_filepath, encoding="utf-8") as f:
+            return [name.strip() for name in f.read().split("\n") if name.strip()]  # Filter empty names
+
+
+@dataclass
+class Sequence:
+    """Construct a list of feature from a single type or a dict of types.
+    Mostly here for compatiblity with tfds.
+
+    Args:
+        feature:
+            A list of features of a single type or a dictionary of types.
+        length (`int`):
+            Length of the sequence.
+
+    Example:
+
+    ```py
+    >>> from datasets import Features, Sequence, Value, ClassLabel
+    >>> features = Features({'post': Sequence(feature={'text': Value(dtype='string'), 'upvotes': Value(dtype='int32'), 'label': ClassLabel(num_classes=2, names=['hot', 'cold'])})})
+    >>> features
+    {'post': Sequence(feature={'text': Value(dtype='string', id=None), 'upvotes': Value(dtype='int32', id=None), 'label': ClassLabel(num_classes=2, names=['hot', 'cold'], id=None)}, length=-1, id=None)}
+    ```
+    """
+
+    feature: Any
+    length: int = -1
+    id: Optional[str] = None
+    # Automatically constructed
+    dtype: ClassVar[str] = "list"
+    pa_type: ClassVar[Any] = None
+    _type: str = field(default="Sequence", init=False, repr=False)
+
+
+FeatureType = Union[
+    dict,
+    list,
+    tuple,
+    Value,
+    ClassLabel,
+    Translation,
+    TranslationVariableLanguages,
+    Sequence,
+    Array2D,
+    Array3D,
+    Array4D,
+    Array5D,
+    Audio,
+    Image,
+]
+
+
+def _check_non_null_non_empty_recursive(obj, schema: Optional[FeatureType] = None) -> bool:
+    """
+    Check if the object is not None.
+    If the object is a list or a tuple, recursively check the first element of the sequence and stop if at any point the first element is not a sequence or is an empty sequence.
+    """
+    if obj is None:
+        return False
+    elif isinstance(obj, (list, tuple)) and (schema is None or isinstance(schema, (list, tuple, Sequence))):
+        if len(obj) > 0:
+            if schema is None:
+                pass
+            elif isinstance(schema, (list, tuple)):
+                schema = schema[0]
+            else:
+                schema = schema.feature
+            return _check_non_null_non_empty_recursive(obj[0], schema)
+        else:
+            return False
+    else:
+        return True
+
+
+def get_nested_type(schema: FeatureType) -> pa.DataType:
+    """
+    get_nested_type() converts a datasets.FeatureType into a pyarrow.DataType, and acts as the inverse of
+        generate_from_arrow_type().
+
+    It performs double-duty as the implementation of Features.type and handles the conversion of
+        datasets.Feature->pa.struct
+    """
+    # Nested structures: we allow dict, list/tuples, sequences
+    if isinstance(schema, Features):
+        return pa.struct(
+            {key: get_nested_type(schema[key]) for key in schema}
+        )  # Features is subclass of dict, and dict order is deterministic since Python 3.6
+    elif isinstance(schema, dict):
+        return pa.struct(
+            {key: get_nested_type(schema[key]) for key in schema}
+        )  # however don't sort on struct types since the order matters
+    elif isinstance(schema, (list, tuple)):
+        if len(schema) != 1:
+            raise ValueError("When defining list feature, you should just provide one example of the inner type")
+        value_type = get_nested_type(schema[0])
+        return pa.list_(value_type)
+    elif isinstance(schema, Sequence):
+        value_type = get_nested_type(schema.feature)
+        # We allow to reverse list of dict => dict of list for compatibility with tfds
+        if isinstance(schema.feature, dict):
+            return pa.struct({f.name: pa.list_(f.type, schema.length) for f in value_type})
+        return pa.list_(value_type, schema.length)
+
+    # Other objects are callable which returns their data type (ClassLabel, Array2D, Translation, Arrow datatype creation methods)
+    return schema()
+
+
+def encode_nested_example(schema, obj, level=0):
+    """Encode a nested example.
+    This is used since some features (in particular ClassLabel) have some logic during encoding.
+
+    To avoid iterating over possibly long lists, it first checks (recursively) if the first element that is not None or empty (if it is a sequence) has to be encoded.
+    If the first element needs to be encoded, then all the elements of the list will be encoded, otherwise they'll stay the same.
+    """
+    # Nested structures: we allow dict, list/tuples, sequences
+    if isinstance(schema, dict):
+        if level == 0 and obj is None:
+            raise ValueError("Got None but expected a dictionary instead")
+        return (
+            {k: encode_nested_example(schema[k], obj.get(k), level=level + 1) for k in schema}
+            if obj is not None
+            else None
+        )
+
+    elif isinstance(schema, (list, tuple)):
+        sub_schema = schema[0]
+        if obj is None:
+            return None
+        else:
+            if len(obj) > 0:
+                for first_elmt in obj:
+                    if _check_non_null_non_empty_recursive(first_elmt, sub_schema):
+                        break
+                if encode_nested_example(sub_schema, first_elmt, level=level + 1) != first_elmt:
+                    return [encode_nested_example(sub_schema, o, level=level + 1) for o in obj]
+            return list(obj)
+    elif isinstance(schema, Sequence):
+        if obj is None:
+            return None
+        # We allow to reverse list of dict => dict of list for compatiblity with tfds
+        if isinstance(schema.feature, dict):
+            # dict of list to fill
+            list_dict = {}
+            if isinstance(obj, (list, tuple)):
+                # obj is a list of dict
+                for k in schema.feature:
+                    list_dict[k] = [encode_nested_example(schema.feature[k], o.get(k), level=level + 1) for o in obj]
+                return list_dict
+            else:
+                # obj is a single dict
+                for k in schema.feature:
+                    list_dict[k] = (
+                        [encode_nested_example(schema.feature[k], o, level=level + 1) for o in obj[k]]
+                        if k in obj
+                        else None
+                    )
+                return list_dict
+        # schema.feature is not a dict
+        if isinstance(obj, str):  # don't interpret a string as a list
+            raise ValueError(f"Got a string but expected a list instead: '{obj}'")
+        else:
+            if len(obj) > 0:
+                for first_elmt in obj:
+                    if _check_non_null_non_empty_recursive(first_elmt, schema.feature):
+                        break
+                # be careful when comparing tensors here
+                if (
+                    not isinstance(first_elmt, list)
+                    or encode_nested_example(schema.feature, first_elmt, level=level + 1) != first_elmt
+                ):
+                    return [encode_nested_example(schema.feature, o, level=level + 1) for o in obj]
+            return list(obj)
+    # Object with special encoding:
+    # ClassLabel will convert from string to int, TranslationVariableLanguages does some checks
+    elif isinstance(schema, (Audio, Image, ClassLabel, TranslationVariableLanguages, Value, _ArrayXD)):
+        return schema.encode_example(obj) if obj is not None else None
+    # Other object should be directly convertible to a native Arrow type (like Translation and Translation)
+    return obj
+
+
+def decode_nested_example(schema, obj, token_per_repo_id: Optional[Dict[str, Union[str, bool, None]]] = None):
+    """Decode a nested example.
+    This is used since some features (in particular Audio and Image) have some logic during decoding.
+
+    To avoid iterating over possibly long lists, it first checks (recursively) if the first element that is not None or empty (if it is a sequence) has to be decoded.
+    If the first element needs to be decoded, then all the elements of the list will be decoded, otherwise they'll stay the same.
+    """
+    # Nested structures: we allow dict, list/tuples, sequences
+    if isinstance(schema, dict):
+        return (
+            {k: decode_nested_example(sub_schema, sub_obj) for k, (sub_schema, sub_obj) in zip_dict(schema, obj)}
+            if obj is not None
+            else None
+        )
+    elif isinstance(schema, (list, tuple)):
+        sub_schema = schema[0]
+        if obj is None:
+            return None
+        else:
+            if len(obj) > 0:
+                for first_elmt in obj:
+                    if _check_non_null_non_empty_recursive(first_elmt, sub_schema):
+                        break
+                if decode_nested_example(sub_schema, first_elmt) != first_elmt:
+                    return [decode_nested_example(sub_schema, o) for o in obj]
+            return list(obj)
+    elif isinstance(schema, Sequence):
+        # We allow to reverse list of dict => dict of list for compatiblity with tfds
+        if isinstance(schema.feature, dict):
+            return {k: decode_nested_example([schema.feature[k]], obj[k]) for k in schema.feature}
+        else:
+            return decode_nested_example([schema.feature], obj)
+    # Object with special decoding:
+    elif isinstance(schema, (Audio, Image)):
+        # we pass the token to read and decode files from private repositories in streaming mode
+        if obj is not None and schema.decode:
+            return schema.decode_example(obj, token_per_repo_id=token_per_repo_id)
+    return obj
+
+
+_FEATURE_TYPES: Dict[str, FeatureType] = {
+    Value.__name__: Value,
+    ClassLabel.__name__: ClassLabel,
+    Translation.__name__: Translation,
+    TranslationVariableLanguages.__name__: TranslationVariableLanguages,
+    Sequence.__name__: Sequence,
+    Array2D.__name__: Array2D,
+    Array3D.__name__: Array3D,
+    Array4D.__name__: Array4D,
+    Array5D.__name__: Array5D,
+    Audio.__name__: Audio,
+    Image.__name__: Image,
+}
+
+
+@experimental
+def register_feature(
+    feature_cls: type,
+    feature_type: str,
+):
+    """
+    Register a Feature object using a name and class.
+    This function must be used on a Feature class.
+    """
+    if feature_type in _FEATURE_TYPES:
+        logger.warning(
+            f"Overwriting feature type '{feature_type}' ({_FEATURE_TYPES[feature_type].__name__} -> {feature_cls.__name__})"
+        )
+    _FEATURE_TYPES[feature_type] = feature_cls
+
+
+def generate_from_dict(obj: Any):
+    """Regenerate the nested feature object from a deserialized dict.
+    We use the '_type' fields to get the dataclass name to load.
+
+    generate_from_dict is the recursive helper for Features.from_dict, and allows for a convenient constructor syntax
+    to define features from deserialized JSON dictionaries. This function is used in particular when deserializing
+    a :class:`DatasetInfo` that was dumped to a JSON object. This acts as an analogue to
+    :meth:`Features.from_arrow_schema` and handles the recursive field-by-field instantiation, but doesn't require any
+    mapping to/from pyarrow, except for the fact that it takes advantage of the mapping of pyarrow primitive dtypes
+    that :class:`Value` automatically performs.
+    """
+    # Nested structures: we allow dict, list/tuples, sequences
+    if isinstance(obj, list):
+        return [generate_from_dict(value) for value in obj]
+    # Otherwise we have a dict or a dataclass
+    if "_type" not in obj or isinstance(obj["_type"], dict):
+        return {key: generate_from_dict(value) for key, value in obj.items()}
+    obj = dict(obj)
+    _type = obj.pop("_type")
+    class_type = _FEATURE_TYPES.get(_type, None) or globals().get(_type, None)
+
+    if class_type is None:
+        raise ValueError(f"Feature type '{_type}' not found. Available feature types: {list(_FEATURE_TYPES.keys())}")
+
+    if class_type == Sequence:
+        return Sequence(feature=generate_from_dict(obj["feature"]), length=obj.get("length", -1))
+
+    field_names = {f.name for f in fields(class_type)}
+    return class_type(**{k: v for k, v in obj.items() if k in field_names})
+
+
+def generate_from_arrow_type(pa_type: pa.DataType) -> FeatureType:
+    """
+    generate_from_arrow_type accepts an arrow DataType and returns a datasets FeatureType to be used as the type for
+        a single field.
+
+    This is the high-level arrow->datasets type conversion and is inverted by get_nested_type().
+
+    This operates at the individual *field* level, whereas Features.from_arrow_schema() operates at the
+        full schema level and holds the methods that represent the bijection from Features<->pyarrow.Schema
+    """
+    if isinstance(pa_type, pa.StructType):
+        return {field.name: generate_from_arrow_type(field.type) for field in pa_type}
+    elif isinstance(pa_type, pa.FixedSizeListType):
+        return Sequence(feature=generate_from_arrow_type(pa_type.value_type), length=pa_type.list_size)
+    elif isinstance(pa_type, pa.ListType):
+        feature = generate_from_arrow_type(pa_type.value_type)
+        if isinstance(feature, (dict, tuple, list)):
+            return [feature]
+        return Sequence(feature=feature)
+    elif isinstance(pa_type, _ArrayXDExtensionType):
+        array_feature = [None, None, Array2D, Array3D, Array4D, Array5D][pa_type.ndims]
+        return array_feature(shape=pa_type.shape, dtype=pa_type.value_type)
+    elif isinstance(pa_type, pa.DictionaryType):
+        raise NotImplementedError  # TODO(thom) this will need access to the dictionary as well (for labels). I.e. to the py_table
+    elif isinstance(pa_type, pa.DataType):
+        return Value(dtype=_arrow_to_datasets_dtype(pa_type))
+    else:
+        raise ValueError(f"Cannot convert {pa_type} to a Feature type.")
+
+
+def numpy_to_pyarrow_listarray(arr: np.ndarray, type: pa.DataType = None) -> pa.ListArray:
+    """Build a PyArrow ListArray from a multidimensional NumPy array"""
+    arr = np.array(arr)
+    values = pa.array(arr.flatten(), type=type)
+    for i in range(arr.ndim - 1):
+        n_offsets = reduce(mul, arr.shape[: arr.ndim - i - 1], 1)
+        step_offsets = arr.shape[arr.ndim - i - 1]
+        offsets = pa.array(np.arange(n_offsets + 1) * step_offsets, type=pa.int32())
+        values = pa.ListArray.from_arrays(offsets, values)
+    return values
+
+
+def list_of_pa_arrays_to_pyarrow_listarray(l_arr: List[Optional[pa.Array]]) -> pa.ListArray:
+    null_mask = np.array([arr is None for arr in l_arr])
+    null_indices = np.arange(len(null_mask))[null_mask] - np.arange(np.sum(null_mask))
+    l_arr = [arr for arr in l_arr if arr is not None]
+    offsets = np.cumsum(
+        [0] + [len(arr) for arr in l_arr], dtype=object
+    )  # convert to dtype object to allow None insertion
+    offsets = np.insert(offsets, null_indices, None)
+    offsets = pa.array(offsets, type=pa.int32())
+    values = pa.concat_arrays(l_arr)
+    return pa.ListArray.from_arrays(offsets, values)
+
+
+def list_of_np_array_to_pyarrow_listarray(l_arr: List[np.ndarray], type: pa.DataType = None) -> pa.ListArray:
+    """Build a PyArrow ListArray from a possibly nested list of NumPy arrays"""
+    if len(l_arr) > 0:
+        return list_of_pa_arrays_to_pyarrow_listarray(
+            [numpy_to_pyarrow_listarray(arr, type=type) if arr is not None else None for arr in l_arr]
+        )
+    else:
+        return pa.array([], type=type)
+
+
+def contains_any_np_array(data: Any):
+    """Return `True` if data is a NumPy ndarray or (recursively) if first non-null value in list is a NumPy ndarray.
+
+    Args:
+        data (Any): Data.
+
+    Returns:
+        bool
+    """
+    if isinstance(data, np.ndarray):
+        return True
+    elif isinstance(data, list):
+        return contains_any_np_array(first_non_null_value(data)[1])
+    else:
+        return False
+
+
+def any_np_array_to_pyarrow_listarray(data: Union[np.ndarray, List], type: pa.DataType = None) -> pa.ListArray:
+    """Convert to PyArrow ListArray either a NumPy ndarray or (recursively) a list that may contain any NumPy ndarray.
+
+    Args:
+        data (Union[np.ndarray, List]): Data.
+        type (pa.DataType): Explicit PyArrow DataType passed to coerce the ListArray data type.
+
+    Returns:
+        pa.ListArray
+    """
+    if isinstance(data, np.ndarray):
+        return numpy_to_pyarrow_listarray(data, type=type)
+    elif isinstance(data, list):
+        return list_of_pa_arrays_to_pyarrow_listarray([any_np_array_to_pyarrow_listarray(i, type=type) for i in data])
+
+
+def to_pyarrow_listarray(data: Any, pa_type: _ArrayXDExtensionType) -> pa.Array:
+    """Convert to PyArrow ListArray.
+
+    Args:
+        data (Any): Sequence, iterable, np.ndarray or pd.Series.
+        pa_type (_ArrayXDExtensionType): Any of the ArrayNDExtensionType.
+
+    Returns:
+        pyarrow.Array
+    """
+    if contains_any_np_array(data):
+        return any_np_array_to_pyarrow_listarray(data, type=pa_type.value_type)
+    else:
+        return pa.array(data, pa_type.storage_dtype)
+
+
+def _visit(feature: FeatureType, func: Callable[[FeatureType], Optional[FeatureType]]) -> FeatureType:
+    """Visit a (possibly nested) feature.
+
+    Args:
+        feature (FeatureType): the feature type to be checked
+    Returns:
+        visited feature (FeatureType)
+    """
+    if isinstance(feature, dict):
+        out = func({k: _visit(f, func) for k, f in feature.items()})
+    elif isinstance(feature, (list, tuple)):
+        out = func([_visit(feature[0], func)])
+    elif isinstance(feature, Sequence):
+        out = func(Sequence(_visit(feature.feature, func), length=feature.length))
+    else:
+        out = func(feature)
+    return feature if out is None else out
+
+
+def require_decoding(feature: FeatureType, ignore_decode_attribute: bool = False) -> bool:
+    """Check if a (possibly nested) feature requires decoding.
+
+    Args:
+        feature (FeatureType): the feature type to be checked
+        ignore_decode_attribute (:obj:`bool`, default ``False``): Whether to ignore the current value
+            of the `decode` attribute of the decodable feature types.
+    Returns:
+        :obj:`bool`
+    """
+    if isinstance(feature, dict):
+        return any(require_decoding(f) for f in feature.values())
+    elif isinstance(feature, (list, tuple)):
+        return require_decoding(feature[0])
+    elif isinstance(feature, Sequence):
+        return require_decoding(feature.feature)
+    else:
+        return hasattr(feature, "decode_example") and (feature.decode if not ignore_decode_attribute else True)
+
+
+def require_storage_cast(feature: FeatureType) -> bool:
+    """Check if a (possibly nested) feature requires storage casting.
+
+    Args:
+        feature (FeatureType): the feature type to be checked
+    Returns:
+        :obj:`bool`
+    """
+    if isinstance(feature, dict):
+        return any(require_storage_cast(f) for f in feature.values())
+    elif isinstance(feature, (list, tuple)):
+        return require_storage_cast(feature[0])
+    elif isinstance(feature, Sequence):
+        return require_storage_cast(feature.feature)
+    else:
+        return hasattr(feature, "cast_storage")
+
+
+def require_storage_embed(feature: FeatureType) -> bool:
+    """Check if a (possibly nested) feature requires embedding data into storage.
+
+    Args:
+        feature (FeatureType): the feature type to be checked
+    Returns:
+        :obj:`bool`
+    """
+    if isinstance(feature, dict):
+        return any(require_storage_cast(f) for f in feature.values())
+    elif isinstance(feature, (list, tuple)):
+        return require_storage_cast(feature[0])
+    elif isinstance(feature, Sequence):
+        return require_storage_cast(feature.feature)
+    else:
+        return hasattr(feature, "embed_storage")
+
+
+def keep_features_dicts_synced(func):
+    """
+    Wrapper to keep the secondary dictionary, which tracks whether keys are decodable, of the :class:`datasets.Features` object
+    in sync with the main dictionary.
+    """
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        if args:
+            self: "Features" = args[0]
+            args = args[1:]
+        else:
+            self: "Features" = kwargs.pop("self")
+        out = func(self, *args, **kwargs)
+        assert hasattr(self, "_column_requires_decoding")
+        self._column_requires_decoding = {col: require_decoding(feature) for col, feature in self.items()}
+        return out
+
+    wrapper._decorator_name_ = "_keep_dicts_synced"
+    return wrapper
+
+
+class Features(dict):
+    """A special dictionary that defines the internal structure of a dataset.
+
+    Instantiated with a dictionary of type `dict[str, FieldType]`, where keys are the desired column names,
+    and values are the type of that column.
+
+    `FieldType` can be one of the following:
+        - a [`~datasets.Value`] feature specifies a single typed value, e.g. `int64` or `string`.
+        - a [`~datasets.ClassLabel`] feature specifies a field with a predefined set of classes which can have labels
+          associated to them and will be stored as integers in the dataset.
+        - a python `dict` which specifies that the field is a nested field containing a mapping of sub-fields to sub-fields
+          features. It's possible to have nested fields of nested fields in an arbitrary manner.
+        - a python `list` or a [`~datasets.Sequence`] specifies that the field contains a list of objects. The python
+          `list` or [`~datasets.Sequence`] should be provided with a single sub-feature as an example of the feature
+          type hosted in this list.
+
+          <Tip>
+
+           A [`~datasets.Sequence`] with a internal dictionary feature will be automatically converted into a dictionary of
+           lists. This behavior is implemented to have a compatilbity layer with the TensorFlow Datasets library but may be
+           un-wanted in some cases. If you don't want this behavior, you can use a python `list` instead of the
+           [`~datasets.Sequence`].
+
+          </Tip>
+
+        - a [`Array2D`], [`Array3D`], [`Array4D`] or [`Array5D`] feature for multidimensional arrays.
+        - an [`Audio`] feature to store the absolute path to an audio file or a dictionary with the relative path
+          to an audio file ("path" key) and its bytes content ("bytes" key). This feature extracts the audio data.
+        - an [`Image`] feature to store the absolute path to an image file, an `np.ndarray` object, a `PIL.Image.Image` object
+          or a dictionary with the relative path to an image file ("path" key) and its bytes content ("bytes" key). This feature extracts the image data.
+        - [`~datasets.Translation`] and [`~datasets.TranslationVariableLanguages`], the two features specific to Machine Translation.
+    """
+
+    def __init__(*args, **kwargs):
+        # self not in the signature to allow passing self as a kwarg
+        if not args:
+            raise TypeError("descriptor '__init__' of 'Features' object needs an argument")
+        self, *args = args
+        super(Features, self).__init__(*args, **kwargs)
+        self._column_requires_decoding: Dict[str, bool] = {
+            col: require_decoding(feature) for col, feature in self.items()
+        }
+
+    __setitem__ = keep_features_dicts_synced(dict.__setitem__)
+    __delitem__ = keep_features_dicts_synced(dict.__delitem__)
+    update = keep_features_dicts_synced(dict.update)
+    setdefault = keep_features_dicts_synced(dict.setdefault)
+    pop = keep_features_dicts_synced(dict.pop)
+    popitem = keep_features_dicts_synced(dict.popitem)
+    clear = keep_features_dicts_synced(dict.clear)
+
+    def __reduce__(self):
+        return Features, (dict(self),)
+
+    @property
+    def type(self):
+        """
+        Features field types.
+
+        Returns:
+            :obj:`pyarrow.DataType`
+        """
+        return get_nested_type(self)
+
+    @property
+    def arrow_schema(self):
+        """
+        Features schema.
+
+        Returns:
+            :obj:`pyarrow.Schema`
+        """
+        hf_metadata = {"info": {"features": self.to_dict()}}
+        return pa.schema(self.type).with_metadata({"huggingface": json.dumps(hf_metadata)})
+
+    @classmethod
+    def from_arrow_schema(cls, pa_schema: pa.Schema) -> "Features":
+        """
+        Construct [`Features`] from Arrow Schema.
+        It also checks the schema metadata for Hugging Face Datasets features.
+        Non-nullable fields are not supported and set to nullable.
+
+        Args:
+            pa_schema (`pyarrow.Schema`):
+                Arrow Schema.
+
+        Returns:
+            [`Features`]
+        """
+        # try to load features from the arrow schema metadata
+        metadata_features = Features()
+        if pa_schema.metadata is not None and "huggingface".encode("utf-8") in pa_schema.metadata:
+            metadata = json.loads(pa_schema.metadata["huggingface".encode("utf-8")].decode())
+            if "info" in metadata and "features" in metadata["info"] and metadata["info"]["features"] is not None:
+                metadata_features = Features.from_dict(metadata["info"]["features"])
+        metadata_features_schema = metadata_features.arrow_schema
+        obj = {
+            field.name: (
+                metadata_features[field.name]
+                if field.name in metadata_features and metadata_features_schema.field(field.name) == field
+                else generate_from_arrow_type(field.type)
+            )
+            for field in pa_schema
+        }
+        return cls(**obj)
+
+    @classmethod
+    def from_dict(cls, dic) -> "Features":
+        """
+        Construct [`Features`] from dict.
+
+        Regenerate the nested feature object from a deserialized dict.
+        We use the `_type` key to infer the dataclass name of the feature `FieldType`.
+
+        It allows for a convenient constructor syntax
+        to define features from deserialized JSON dictionaries. This function is used in particular when deserializing
+        a [`DatasetInfo`] that was dumped to a JSON object. This acts as an analogue to
+        [`Features.from_arrow_schema`] and handles the recursive field-by-field instantiation, but doesn't require
+        any mapping to/from pyarrow, except for the fact that it takes advantage of the mapping of pyarrow primitive
+        dtypes that [`Value`] automatically performs.
+
+        Args:
+            dic (`dict[str, Any]`):
+                Python dictionary.
+
+        Returns:
+            `Features`
+
+        Example::
+            >>> Features.from_dict({'_type': {'dtype': 'string', 'id': None, '_type': 'Value'}})
+            {'_type': Value(dtype='string', id=None)}
+        """
+        obj = generate_from_dict(dic)
+        return cls(**obj)
+
+    def to_dict(self):
+        return asdict(self)
+
+    def _to_yaml_list(self) -> list:
+        # we compute the YAML list from the dict representation that is used for JSON dump
+        yaml_data = self.to_dict()
+
+        def simplify(feature: dict) -> dict:
+            if not isinstance(feature, dict):
+                raise TypeError(f"Expected a dict but got a {type(feature)}: {feature}")
+
+            #
+            # sequence:                 ->              sequence: int32
+            #   dtype: int32            ->
+            #
+            if isinstance(feature.get("sequence"), dict) and list(feature["sequence"]) == ["dtype"]:
+                feature["sequence"] = feature["sequence"]["dtype"]
+
+            #
+            # sequence:                 ->              sequence:
+            #   struct:                 ->              - name: foo
+            #   - name: foo             ->                dtype: int32
+            #     dtype: int32          ->
+            #
+            if isinstance(feature.get("sequence"), dict) and list(feature["sequence"]) == ["struct"]:
+                feature["sequence"] = feature["sequence"]["struct"]
+
+            #
+            # list:                     ->              list: int32
+            #   dtype: int32            ->
+            #
+            if isinstance(feature.get("list"), dict) and list(feature["list"]) == ["dtype"]:
+                feature["list"] = feature["list"]["dtype"]
+
+            #
+            # list:                     ->              list:
+            #   struct:                 ->              - name: foo
+            #   - name: foo             ->                dtype: int32
+            #     dtype: int32          ->
+            #
+            if isinstance(feature.get("list"), dict) and list(feature["list"]) == ["struct"]:
+                feature["list"] = feature["list"]["struct"]
+
+            #
+            # class_label:              ->              class_label:
+            #   names:                  ->                names:
+            #   - negative              ->                  '0': negative
+            #   - positive              ->                  '1': positive
+            #
+            if isinstance(feature.get("class_label"), dict) and isinstance(feature["class_label"].get("names"), list):
+                # server-side requirement: keys must be strings
+                feature["class_label"]["names"] = {
+                    str(label_id): label_name for label_id, label_name in enumerate(feature["class_label"]["names"])
+                }
+            return feature
+
+        def to_yaml_inner(obj: Union[dict, list]) -> dict:
+            if isinstance(obj, dict):
+                _type = obj.pop("_type", None)
+                if _type == "Sequence":
+                    _feature = obj.pop("feature")
+                    return simplify({"sequence": to_yaml_inner(_feature), **obj})
+                elif _type == "Value":
+                    return obj
+                elif _type and not obj:
+                    return {"dtype": camelcase_to_snakecase(_type)}
+                elif _type:
+                    return {"dtype": simplify({camelcase_to_snakecase(_type): obj})}
+                else:
+                    return {"struct": [{"name": name, **to_yaml_inner(_feature)} for name, _feature in obj.items()]}
+            elif isinstance(obj, list):
+                return simplify({"list": simplify(to_yaml_inner(obj[0]))})
+            elif isinstance(obj, tuple):
+                return to_yaml_inner(list(obj))
+            else:
+                raise TypeError(f"Expected a dict or a list but got {type(obj)}: {obj}")
+
+        def to_yaml_types(obj: dict) -> dict:
+            if isinstance(obj, dict):
+                return {k: to_yaml_types(v) for k, v in obj.items()}
+            elif isinstance(obj, list):
+                return [to_yaml_types(v) for v in obj]
+            elif isinstance(obj, tuple):
+                return to_yaml_types(list(obj))
+            else:
+                return obj
+
+        return to_yaml_types(to_yaml_inner(yaml_data)["struct"])
+
+    @classmethod
+    def _from_yaml_list(cls, yaml_data: list) -> "Features":
+        yaml_data = copy.deepcopy(yaml_data)
+
+        # we convert the list obtained from YAML data into the dict representation that is used for JSON dump
+
+        def unsimplify(feature: dict) -> dict:
+            if not isinstance(feature, dict):
+                raise TypeError(f"Expected a dict but got a {type(feature)}: {feature}")
+            #
+            # sequence: int32           ->              sequence:
+            #                           ->                dtype: int32
+            #
+            if isinstance(feature.get("sequence"), str):
+                feature["sequence"] = {"dtype": feature["sequence"]}
+            #
+            # list: int32               ->              list:
+            #                           ->                dtype: int32
+            #
+            if isinstance(feature.get("list"), str):
+                feature["list"] = {"dtype": feature["list"]}
+
+            #
+            # class_label:              ->              class_label:
+            #   names:                  ->                names:
+            #     '0': negative              ->               - negative
+            #     '1': positive              ->               - positive
+            #
+            if isinstance(feature.get("class_label"), dict) and isinstance(feature["class_label"].get("names"), dict):
+                label_ids = sorted(feature["class_label"]["names"], key=int)
+                if label_ids and [int(label_id) for label_id in label_ids] != list(range(int(label_ids[-1]) + 1)):
+                    raise ValueError(
+                        f"ClassLabel expected a value for all label ids [0:{int(label_ids[-1]) + 1}] but some ids are missing."
+                    )
+                feature["class_label"]["names"] = [feature["class_label"]["names"][label_id] for label_id in label_ids]
+            return feature
+
+        def from_yaml_inner(obj: Union[dict, list]) -> Union[dict, list]:
+            if isinstance(obj, dict):
+                if not obj:
+                    return {}
+                _type = next(iter(obj))
+                if _type == "sequence":
+                    _feature = unsimplify(obj).pop(_type)
+                    return {"feature": from_yaml_inner(_feature), **obj, "_type": "Sequence"}
+                if _type == "list":
+                    return [from_yaml_inner(unsimplify(obj)[_type])]
+                if _type == "struct":
+                    return from_yaml_inner(obj["struct"])
+                elif _type == "dtype":
+                    if isinstance(obj["dtype"], str):
+                        # e.g. int32, float64, string, audio, image
+                        try:
+                            Value(obj["dtype"])
+                            return {**obj, "_type": "Value"}
+                        except ValueError:
+                            # e.g. Audio, Image, ArrayXD
+                            return {"_type": snakecase_to_camelcase(obj["dtype"])}
+                    else:
+                        return from_yaml_inner(obj["dtype"])
+                else:
+                    return {"_type": snakecase_to_camelcase(_type), **unsimplify(obj)[_type]}
+            elif isinstance(obj, list):
+                names = [_feature.pop("name") for _feature in obj]
+                return {name: from_yaml_inner(_feature) for name, _feature in zip(names, obj)}
+            else:
+                raise TypeError(f"Expected a dict or a list but got {type(obj)}: {obj}")
+
+        return cls.from_dict(from_yaml_inner(yaml_data))
+
+    def encode_example(self, example):
+        """
+        Encode example into a format for Arrow.
+
+        Args:
+            example (`dict[str, Any]`):
+                Data in a Dataset row.
+
+        Returns:
+            `dict[str, Any]`
+        """
+        example = cast_to_python_objects(example)
+        return encode_nested_example(self, example)
+
+    def encode_column(self, column, column_name: str):
+        """
+        Encode column into a format for Arrow.
+
+        Args:
+            column (`list[Any]`):
+                Data in a Dataset column.
+            column_name (`str`):
+                Dataset column name.
+
+        Returns:
+            `list[Any]`
+        """
+        column = cast_to_python_objects(column)
+        return [encode_nested_example(self[column_name], obj, level=1) for obj in column]
+
+    def encode_batch(self, batch):
+        """
+        Encode batch into a format for Arrow.
+
+        Args:
+            batch (`dict[str, list[Any]]`):
+                Data in a Dataset batch.
+
+        Returns:
+            `dict[str, list[Any]]`
+        """
+        encoded_batch = {}
+        if set(batch) != set(self):
+            raise ValueError(f"Column mismatch between batch {set(batch)} and features {set(self)}")
+        for key, column in batch.items():
+            column = cast_to_python_objects(column)
+            encoded_batch[key] = [encode_nested_example(self[key], obj, level=1) for obj in column]
+        return encoded_batch
+
+    def decode_example(self, example: dict, token_per_repo_id: Optional[Dict[str, Union[str, bool, None]]] = None):
+        """Decode example with custom feature decoding.
+
+        Args:
+            example (`dict[str, Any]`):
+                Dataset row data.
+            token_per_repo_id (`dict`, *optional*):
+                To access and decode audio or image files from private repositories on the Hub, you can pass
+                a dictionary `repo_id (str) -> token (bool or str)`.
+
+        Returns:
+            `dict[str, Any]`
+        """
+
+        return {
+            column_name: decode_nested_example(feature, value, token_per_repo_id=token_per_repo_id)
+            if self._column_requires_decoding[column_name]
+            else value
+            for column_name, (feature, value) in zip_dict(
+                {key: value for key, value in self.items() if key in example}, example
+            )
+        }
+
+    def decode_column(self, column: list, column_name: str):
+        """Decode column with custom feature decoding.
+
+        Args:
+            column (`list[Any]`):
+                Dataset column data.
+            column_name (`str`):
+                Dataset column name.
+
+        Returns:
+            `list[Any]`
+        """
+        return (
+            [decode_nested_example(self[column_name], value) if value is not None else None for value in column]
+            if self._column_requires_decoding[column_name]
+            else column
+        )
+
+    def decode_batch(self, batch: dict, token_per_repo_id: Optional[Dict[str, Union[str, bool, None]]] = None):
+        """Decode batch with custom feature decoding.
+
+        Args:
+            batch (`dict[str, list[Any]]`):
+                Dataset batch data.
+            token_per_repo_id (`dict`, *optional*):
+                To access and decode audio or image files from private repositories on the Hub, you can pass
+                a dictionary repo_id (str) -> token (bool or str)
+
+        Returns:
+            `dict[str, list[Any]]`
+        """
+        decoded_batch = {}
+        for column_name, column in batch.items():
+            decoded_batch[column_name] = (
+                [
+                    decode_nested_example(self[column_name], value, token_per_repo_id=token_per_repo_id)
+                    if value is not None
+                    else None
+                    for value in column
+                ]
+                if self._column_requires_decoding[column_name]
+                else column
+            )
+        return decoded_batch
+
+    def copy(self) -> "Features":
+        """
+        Make a deep copy of [`Features`].
+
+        Returns:
+            [`Features`]
+
+        Example:
+
+        ```py
+        >>> from datasets import load_dataset
+        >>> ds = load_dataset("rotten_tomatoes", split="train")
+        >>> copy_of_features = ds.features.copy()
+        >>> copy_of_features
+        {'label': ClassLabel(num_classes=2, names=['neg', 'pos'], id=None),
+         'text': Value(dtype='string', id=None)}
+        ```
+        """
+        return copy.deepcopy(self)
+
+    def reorder_fields_as(self, other: "Features") -> "Features":
+        """
+        Reorder Features fields to match the field order of other [`Features`].
+
+        The order of the fields is important since it matters for the underlying arrow data.
+        Re-ordering the fields allows to make the underlying arrow data type match.
+
+        Args:
+            other ([`Features`]):
+                The other [`Features`] to align with.
+
+        Returns:
+            [`Features`]
+
+        Example::
+
+            >>> from datasets import Features, Sequence, Value
+            >>> # let's say we have to features with a different order of nested fields (for a and b for example)
+            >>> f1 = Features({"root": Sequence({"a": Value("string"), "b": Value("string")})})
+            >>> f2 = Features({"root": {"b": Sequence(Value("string")), "a": Sequence(Value("string"))}})
+            >>> assert f1.type != f2.type
+            >>> # re-ordering keeps the base structure (here Sequence is defined at the root level), but make the fields order match
+            >>> f1.reorder_fields_as(f2)
+            {'root': Sequence(feature={'b': Value(dtype='string', id=None), 'a': Value(dtype='string', id=None)}, length=-1, id=None)}
+            >>> assert f1.reorder_fields_as(f2).type == f2.type
+        """
+
+        def recursive_reorder(source, target, stack=""):
+            stack_position = " at " + stack[1:] if stack else ""
+            if isinstance(target, Sequence):
+                target = target.feature
+                if isinstance(target, dict):
+                    target = {k: [v] for k, v in target.items()}
+                else:
+                    target = [target]
+            if isinstance(source, Sequence):
+                source, id_, length = source.feature, source.id, source.length
+                if isinstance(source, dict):
+                    source = {k: [v] for k, v in source.items()}
+                    reordered = recursive_reorder(source, target, stack)
+                    return Sequence({k: v[0] for k, v in reordered.items()}, id=id_, length=length)
+                else:
+                    source = [source]
+                    reordered = recursive_reorder(source, target, stack)
+                    return Sequence(reordered[0], id=id_, length=length)
+            elif isinstance(source, dict):
+                if not isinstance(target, dict):
+                    raise ValueError(f"Type mismatch: between {source} and {target}" + stack_position)
+                if sorted(source) != sorted(target):
+                    message = (
+                        f"Keys mismatch: between {source} (source) and {target} (target).\n"
+                        f"{source.keys()-target.keys()} are missing from target "
+                        f"and {target.keys()-source.keys()} are missing from source" + stack_position
+                    )
+                    raise ValueError(message)
+                return {key: recursive_reorder(source[key], target[key], stack + f".{key}") for key in target}
+            elif isinstance(source, list):
+                if not isinstance(target, list):
+                    raise ValueError(f"Type mismatch: between {source} and {target}" + stack_position)
+                if len(source) != len(target):
+                    raise ValueError(f"Length mismatch: between {source} and {target}" + stack_position)
+                return [recursive_reorder(source[i], target[i], stack + ".<list>") for i in range(len(target))]
+            else:
+                return source
+
+        return Features(recursive_reorder(self, other))
+
+    def flatten(self, max_depth=16) -> "Features":
+        """Flatten the features. Every dictionary column is removed and is replaced by
+        all the subfields it contains. The new fields are named by concatenating the
+        name of the original column and the subfield name like this: `<original>.<subfield>`.
+
+        If a column contains nested dictionaries, then all the lower-level subfields names are
+        also concatenated to form new columns: `<original>.<subfield>.<subsubfield>`, etc.
+
+        Returns:
+            [`Features`]:
+                The flattened features.
+
+        Example:
+
+        ```py
+        >>> from datasets import load_dataset
+        >>> ds = load_dataset("squad", split="train")
+        >>> ds.features.flatten()
+        {'answers.answer_start': Sequence(feature=Value(dtype='int32', id=None), length=-1, id=None),
+         'answers.text': Sequence(feature=Value(dtype='string', id=None), length=-1, id=None),
+         'context': Value(dtype='string', id=None),
+         'id': Value(dtype='string', id=None),
+         'question': Value(dtype='string', id=None),
+         'title': Value(dtype='string', id=None)}
+        ```
+        """
+        for depth in range(1, max_depth):
+            no_change = True
+            flattened = self.copy()
+            for column_name, subfeature in self.items():
+                if isinstance(subfeature, dict):
+                    no_change = False
+                    flattened.update({f"{column_name}.{k}": v for k, v in subfeature.items()})
+                    del flattened[column_name]
+                elif isinstance(subfeature, Sequence) and isinstance(subfeature.feature, dict):
+                    no_change = False
+                    flattened.update(
+                        {
+                            f"{column_name}.{k}": Sequence(v) if not isinstance(v, dict) else [v]
+                            for k, v in subfeature.feature.items()
+                        }
+                    )
+                    del flattened[column_name]
+                elif hasattr(subfeature, "flatten") and subfeature.flatten() != subfeature:
+                    no_change = False
+                    flattened.update({f"{column_name}.{k}": v for k, v in subfeature.flatten().items()})
+                    del flattened[column_name]
+            self = flattened
+            if no_change:
+                break
+        return self
+
+
+def _align_features(features_list: List[Features]) -> List[Features]:
+    """Align dictionaries of features so that the keys that are found in multiple dictionaries share the same feature."""
+    name2feature = {}
+    for features in features_list:
+        for k, v in features.items():
+            if k in name2feature and isinstance(v, dict):
+                # Recursively align features.
+                name2feature[k] = _align_features([name2feature[k], v])[0]
+            elif k not in name2feature or (isinstance(name2feature[k], Value) and name2feature[k].dtype == "null"):
+                name2feature[k] = v
+
+    return [Features({k: name2feature[k] for k in features.keys()}) for features in features_list]
+
+
+def _check_if_features_can_be_aligned(features_list: List[Features]):
+    """Check if the dictionaries of features can be aligned.
+
+    Two dictonaries of features can be aligned if the keys they share have the same type or some of them is of type `Value("null")`.
+    """
+    name2feature = {}
+    for features in features_list:
+        for k, v in features.items():
+            if k not in name2feature or (isinstance(name2feature[k], Value) and name2feature[k].dtype == "null"):
+                name2feature[k] = v
+
+    for features in features_list:
+        for k, v in features.items():
+            if isinstance(v, dict) and isinstance(name2feature[k], dict):
+                # Deep checks for structure.
+                _check_if_features_can_be_aligned([name2feature[k], v])
+            elif not (isinstance(v, Value) and v.dtype == "null") and name2feature[k] != v:
+                raise ValueError(
+                    f'The features can\'t be aligned because the key {k} of features {features} has unexpected type - {v} (expected either {name2feature[k]} or Value("null").'
+                )

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

@@ -0,0 +1,383 @@
+import os
+import sys
+import warnings
+from dataclasses import dataclass, field
+from io import BytesIO
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Union
+
+import numpy as np
+import pyarrow as pa
+
+from .. import config
+from ..download.download_config import DownloadConfig
+from ..table import array_cast
+from ..utils.file_utils import is_local_path, xopen
+from ..utils.py_utils import first_non_null_value, no_op_if_value_is_null, string_to_dict
+
+
+if TYPE_CHECKING:
+    import PIL.Image
+
+    from .features import FeatureType
+
+
+_IMAGE_COMPRESSION_FORMATS: Optional[List[str]] = None
+_NATIVE_BYTEORDER = "<" if sys.byteorder == "little" else ">"
+# Origin: https://github.com/python-pillow/Pillow/blob/698951e19e19972aeed56df686868f1329981c12/src/PIL/Image.py#L3126 minus "|i1" which values are not preserved correctly when saving and loading an image
+_VALID_IMAGE_ARRAY_DTPYES = [
+    np.dtype("|b1"),
+    np.dtype("|u1"),
+    np.dtype("<u2"),
+    np.dtype(">u2"),
+    np.dtype("<i2"),
+    np.dtype(">i2"),
+    np.dtype("<u4"),
+    np.dtype(">u4"),
+    np.dtype("<i4"),
+    np.dtype(">i4"),
+    np.dtype("<f4"),
+    np.dtype(">f4"),
+    np.dtype("<f8"),
+    np.dtype(">f8"),
+]
+
+
+@dataclass
+class Image:
+    """Image [`Feature`] to read image data from an image file.
+
+    Input: The Image feature accepts as input:
+    - A `str`: Absolute path to the image file (i.e. random access is allowed).
+    - A `dict` with the keys:
+
+        - `path`: String with relative path of the image file to the archive file.
+        - `bytes`: Bytes of the image file.
+
+      This is useful for archived files with sequential access.
+
+    - An `np.ndarray`: NumPy array representing an image.
+    - A `PIL.Image.Image`: PIL image object.
+
+    Args:
+        mode (`str`, *optional*):
+            The mode to convert the image to. If `None`, the native mode of the image is used.
+        decode (`bool`, defaults to `True`):
+            Whether to decode the image data. If `False`,
+            returns the underlying dictionary in the format `{"path": image_path, "bytes": image_bytes}`.
+
+    Examples:
+
+    ```py
+    >>> from datasets import load_dataset, Image
+    >>> ds = load_dataset("beans", split="train")
+    >>> ds.features["image"]
+    Image(decode=True, id=None)
+    >>> ds[0]["image"]
+    <PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=500x500 at 0x15E52E7F0>
+    >>> ds = ds.cast_column('image', Image(decode=False))
+    {'bytes': None,
+     'path': '/root/.cache/huggingface/datasets/downloads/extracted/b0a21163f78769a2cf11f58dfc767fb458fc7cea5c05dccc0144a2c0f0bc1292/train/healthy/healthy_train.85.jpg'}
+    ```
+    """
+
+    mode: Optional[str] = None
+    decode: bool = True
+    id: Optional[str] = None
+    # Automatically constructed
+    dtype: ClassVar[str] = "PIL.Image.Image"
+    pa_type: ClassVar[Any] = pa.struct({"bytes": pa.binary(), "path": pa.string()})
+    _type: str = field(default="Image", init=False, repr=False)
+
+    def __call__(self):
+        return self.pa_type
+
+    def encode_example(self, value: Union[str, bytes, dict, np.ndarray, "PIL.Image.Image"]) -> dict:
+        """Encode example into a format for Arrow.
+
+        Args:
+            value (`str`, `np.ndarray`, `PIL.Image.Image` or `dict`):
+                Data passed as input to Image feature.
+
+        Returns:
+            `dict` with "path" and "bytes" fields
+        """
+        if config.PIL_AVAILABLE:
+            import PIL.Image
+        else:
+            raise ImportError("To support encoding images, please install 'Pillow'.")
+
+        if isinstance(value, list):
+            value = np.array(value)
+
+        if isinstance(value, str):
+            return {"path": value, "bytes": None}
+        elif isinstance(value, bytes):
+            return {"path": None, "bytes": value}
+        elif isinstance(value, np.ndarray):
+            # convert the image array to PNG/TIFF bytes
+            return encode_np_array(value)
+        elif isinstance(value, PIL.Image.Image):
+            # convert the PIL image to bytes (default format is PNG/TIFF)
+            return encode_pil_image(value)
+        elif value.get("path") is not None and os.path.isfile(value["path"]):
+            # we set "bytes": None to not duplicate the data if they're already available locally
+            return {"bytes": None, "path": value.get("path")}
+        elif value.get("bytes") is not None or value.get("path") is not None:
+            # store the image bytes, and path is used to infer the image format using the file extension
+            return {"bytes": value.get("bytes"), "path": value.get("path")}
+        else:
+            raise ValueError(
+                f"An image sample should have one of 'path' or 'bytes' but they are missing or None in {value}."
+            )
+
+    def decode_example(self, value: dict, token_per_repo_id=None) -> "PIL.Image.Image":
+        """Decode example image file into image data.
+
+        Args:
+            value (`str` or `dict`):
+                A string with the absolute image file path, a dictionary with
+                keys:
+
+                - `path`: String with absolute or relative image file path.
+                - `bytes`: The bytes of the image file.
+            token_per_repo_id (`dict`, *optional*):
+                To access and decode
+                image files from private repositories on the Hub, you can pass
+                a dictionary repo_id (`str`) -> token (`bool` or `str`).
+
+        Returns:
+            `PIL.Image.Image`
+        """
+        if not self.decode:
+            raise RuntimeError("Decoding is disabled for this feature. Please use Image(decode=True) instead.")
+
+        if config.PIL_AVAILABLE:
+            import PIL.Image
+            import PIL.ImageOps
+        else:
+            raise ImportError("To support decoding images, please install 'Pillow'.")
+
+        if token_per_repo_id is None:
+            token_per_repo_id = {}
+
+        path, bytes_ = value["path"], value["bytes"]
+        if bytes_ is None:
+            if path is None:
+                raise ValueError(f"An image should have one of 'path' or 'bytes' but both are None in {value}.")
+            else:
+                if is_local_path(path):
+                    image = PIL.Image.open(path)
+                else:
+                    source_url = path.split("::")[-1]
+                    pattern = (
+                        config.HUB_DATASETS_URL
+                        if source_url.startswith(config.HF_ENDPOINT)
+                        else config.HUB_DATASETS_HFFS_URL
+                    )
+                    try:
+                        repo_id = string_to_dict(source_url, pattern)["repo_id"]
+                        token = token_per_repo_id.get(repo_id)
+                    except ValueError:
+                        token = None
+                    download_config = DownloadConfig(token=token)
+                    with xopen(path, "rb", download_config=download_config) as f:
+                        bytes_ = BytesIO(f.read())
+                    image = PIL.Image.open(bytes_)
+        else:
+            image = PIL.Image.open(BytesIO(bytes_))
+        image.load()  # to avoid "Too many open files" errors
+        if image.getexif().get(PIL.Image.ExifTags.Base.Orientation) is not None:
+            image = PIL.ImageOps.exif_transpose(image)
+        if self.mode and self.mode != image.mode:
+            image = image.convert(self.mode)
+        return image
+
+    def flatten(self) -> Union["FeatureType", Dict[str, "FeatureType"]]:
+        """If in the decodable state, return the feature itself, otherwise flatten the feature into a dictionary."""
+        from .features import Value
+
+        return (
+            self
+            if self.decode
+            else {
+                "bytes": Value("binary"),
+                "path": Value("string"),
+            }
+        )
+
+    def cast_storage(self, storage: Union[pa.StringArray, pa.StructArray, pa.ListArray]) -> pa.StructArray:
+        """Cast an Arrow array to the Image arrow storage type.
+        The Arrow types that can be converted to the Image pyarrow storage type are:
+
+        - `pa.string()` - it must contain the "path" data
+        - `pa.binary()` - it must contain the image bytes
+        - `pa.struct({"bytes": pa.binary()})`
+        - `pa.struct({"path": pa.string()})`
+        - `pa.struct({"bytes": pa.binary(), "path": pa.string()})`  - order doesn't matter
+        - `pa.list(*)` - it must contain the image array data
+
+        Args:
+            storage (`Union[pa.StringArray, pa.StructArray, pa.ListArray]`):
+                PyArrow array to cast.
+
+        Returns:
+            `pa.StructArray`: Array in the Image arrow storage type, that is
+                `pa.struct({"bytes": pa.binary(), "path": pa.string()})`.
+        """
+        if pa.types.is_string(storage.type):
+            bytes_array = pa.array([None] * len(storage), type=pa.binary())
+            storage = pa.StructArray.from_arrays([bytes_array, storage], ["bytes", "path"], mask=storage.is_null())
+        elif pa.types.is_binary(storage.type):
+            path_array = pa.array([None] * len(storage), type=pa.string())
+            storage = pa.StructArray.from_arrays([storage, path_array], ["bytes", "path"], mask=storage.is_null())
+        elif pa.types.is_struct(storage.type):
+            if storage.type.get_field_index("bytes") >= 0:
+                bytes_array = storage.field("bytes")
+            else:
+                bytes_array = pa.array([None] * len(storage), type=pa.binary())
+            if storage.type.get_field_index("path") >= 0:
+                path_array = storage.field("path")
+            else:
+                path_array = pa.array([None] * len(storage), type=pa.string())
+            storage = pa.StructArray.from_arrays([bytes_array, path_array], ["bytes", "path"], mask=storage.is_null())
+        elif pa.types.is_list(storage.type):
+            bytes_array = pa.array(
+                [encode_np_array(np.array(arr))["bytes"] if arr is not None else None for arr in storage.to_pylist()],
+                type=pa.binary(),
+            )
+            path_array = pa.array([None] * len(storage), type=pa.string())
+            storage = pa.StructArray.from_arrays(
+                [bytes_array, path_array], ["bytes", "path"], mask=bytes_array.is_null()
+            )
+        return array_cast(storage, self.pa_type)
+
+    def embed_storage(self, storage: pa.StructArray) -> pa.StructArray:
+        """Embed image files into the Arrow array.
+
+        Args:
+            storage (`pa.StructArray`):
+                PyArrow array to embed.
+
+        Returns:
+            `pa.StructArray`: Array in the Image arrow storage type, that is
+                `pa.struct({"bytes": pa.binary(), "path": pa.string()})`.
+        """
+
+        @no_op_if_value_is_null
+        def path_to_bytes(path):
+            with xopen(path, "rb") as f:
+                bytes_ = f.read()
+            return bytes_
+
+        bytes_array = pa.array(
+            [
+                (path_to_bytes(x["path"]) if x["bytes"] is None else x["bytes"]) if x is not None else None
+                for x in storage.to_pylist()
+            ],
+            type=pa.binary(),
+        )
+        path_array = pa.array(
+            [os.path.basename(path) if path is not None else None for path in storage.field("path").to_pylist()],
+            type=pa.string(),
+        )
+        storage = pa.StructArray.from_arrays([bytes_array, path_array], ["bytes", "path"], mask=bytes_array.is_null())
+        return array_cast(storage, self.pa_type)
+
+
+def list_image_compression_formats() -> List[str]:
+    if config.PIL_AVAILABLE:
+        import PIL.Image
+    else:
+        raise ImportError("To support encoding images, please install 'Pillow'.")
+
+    global _IMAGE_COMPRESSION_FORMATS
+    if _IMAGE_COMPRESSION_FORMATS is None:
+        PIL.Image.init()
+        _IMAGE_COMPRESSION_FORMATS = list(set(PIL.Image.OPEN.keys()) & set(PIL.Image.SAVE.keys()))
+    return _IMAGE_COMPRESSION_FORMATS
+
+
+def image_to_bytes(image: "PIL.Image.Image") -> bytes:
+    """Convert a PIL Image object to bytes using native compression if possible, otherwise use PNG/TIFF compression."""
+    buffer = BytesIO()
+    if image.format in list_image_compression_formats():
+        format = image.format
+    else:
+        format = "PNG" if image.mode in ["1", "L", "LA", "RGB", "RGBA"] else "TIFF"
+    image.save(buffer, format=format)
+    return buffer.getvalue()
+
+
+def encode_pil_image(image: "PIL.Image.Image") -> dict:
+    if hasattr(image, "filename") and image.filename != "":
+        return {"path": image.filename, "bytes": None}
+    else:
+        return {"path": None, "bytes": image_to_bytes(image)}
+
+
+def encode_np_array(array: np.ndarray) -> dict:
+    if config.PIL_AVAILABLE:
+        import PIL.Image
+    else:
+        raise ImportError("To support encoding images, please install 'Pillow'.")
+
+    dtype = array.dtype
+    dtype_byteorder = dtype.byteorder if dtype.byteorder != "=" else _NATIVE_BYTEORDER
+    dtype_kind = dtype.kind
+    dtype_itemsize = dtype.itemsize
+
+    dest_dtype = None
+
+    # Multi-channel array case (only np.dtype("|u1") is allowed)
+    if array.shape[2:]:
+        if dtype_kind not in ["u", "i"]:
+            raise TypeError(
+                f"Unsupported array dtype {dtype} for image encoding. Only {dest_dtype} is supported for multi-channel arrays."
+            )
+        dest_dtype = np.dtype("|u1")
+        if dtype != dest_dtype:
+            warnings.warn(f"Downcasting array dtype {dtype} to {dest_dtype} to be compatible with 'Pillow'")
+    # Exact match
+    elif dtype in _VALID_IMAGE_ARRAY_DTPYES:
+        dest_dtype = dtype
+    else:  # Downcast the type within the kind (np.can_cast(from_type, to_type, casting="same_kind") doesn't behave as expected, so do it manually)
+        while dtype_itemsize >= 1:
+            dtype_str = dtype_byteorder + dtype_kind + str(dtype_itemsize)
+            if np.dtype(dtype_str) in _VALID_IMAGE_ARRAY_DTPYES:
+                dest_dtype = np.dtype(dtype_str)
+                warnings.warn(f"Downcasting array dtype {dtype} to {dest_dtype} to be compatible with 'Pillow'")
+                break
+            else:
+                dtype_itemsize //= 2
+        if dest_dtype is None:
+            raise TypeError(
+                f"Cannot downcast dtype {dtype} to a valid image dtype. Valid image dtypes: {_VALID_IMAGE_ARRAY_DTPYES}"
+            )
+
+    image = PIL.Image.fromarray(array.astype(dest_dtype))
+    return {"path": None, "bytes": image_to_bytes(image)}
+
+
+def objects_to_list_of_image_dicts(
+    objs: Union[List[str], List[dict], List[np.ndarray], List["PIL.Image.Image"]],
+) -> List[dict]:
+    """Encode a list of objects into a format suitable for creating an extension array of type `ImageExtensionType`."""
+    if config.PIL_AVAILABLE:
+        import PIL.Image
+    else:
+        raise ImportError("To support encoding images, please install 'Pillow'.")
+
+    if objs:
+        _, obj = first_non_null_value(objs)
+        if isinstance(obj, str):
+            return [{"path": obj, "bytes": None} if obj is not None else None for obj in objs]
+        if isinstance(obj, np.ndarray):
+            obj_to_image_dict_func = no_op_if_value_is_null(encode_np_array)
+            return [obj_to_image_dict_func(obj) for obj in objs]
+        elif isinstance(obj, PIL.Image.Image):
+            obj_to_image_dict_func = no_op_if_value_is_null(encode_pil_image)
+            return [obj_to_image_dict_func(obj) for obj in objs]
+        else:
+            return objs
+    else:
+        return objs

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

@@ -0,0 +1,129 @@
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Union
+
+import pyarrow as pa
+
+
+if TYPE_CHECKING:
+    from .features import FeatureType
+
+
+@dataclass
+class Translation:
+    """`FeatureConnector` for translations with fixed languages per example.
+    Here for compatiblity with tfds.
+
+    Args:
+        languages (`dict`):
+            A dictionary for each example mapping string language codes to string translations.
+
+    Example:
+
+    ```python
+    >>> # At construction time:
+    >>> datasets.features.Translation(languages=['en', 'fr', 'de'])
+    >>> # During data generation:
+    >>> yield {
+    ...         'en': 'the cat',
+    ...         'fr': 'le chat',
+    ...         'de': 'die katze'
+    ... }
+    ```
+    """
+
+    languages: List[str]
+    id: Optional[str] = None
+    # Automatically constructed
+    dtype: ClassVar[str] = "dict"
+    pa_type: ClassVar[Any] = None
+    _type: str = field(default="Translation", init=False, repr=False)
+
+    def __call__(self):
+        return pa.struct({lang: pa.string() for lang in sorted(self.languages)})
+
+    def flatten(self) -> Union["FeatureType", Dict[str, "FeatureType"]]:
+        """Flatten the Translation feature into a dictionary."""
+        from .features import Value
+
+        return {k: Value("string") for k in sorted(self.languages)}
+
+
+@dataclass
+class TranslationVariableLanguages:
+    """`FeatureConnector` for translations with variable languages per example.
+    Here for compatiblity with tfds.
+
+    Args:
+        languages (`dict`):
+            A dictionary for each example mapping string language codes to one or more string translations.
+            The languages present may vary from example to example.
+
+    Returns:
+        - `language` or `translation` (variable-length 1D `tf.Tensor` of `tf.string`):
+            Language codes sorted in ascending order or plain text translations, sorted to align with language codes.
+
+    Example:
+
+    ```python
+    >>> # At construction time:
+    >>> datasets.features.TranslationVariableLanguages(languages=['en', 'fr', 'de'])
+    >>> # During data generation:
+    >>> yield {
+    ...         'en': 'the cat',
+    ...         'fr': ['le chat', 'la chatte,']
+    ...         'de': 'die katze'
+    ... }
+    >>> # Tensor returned :
+    >>> {
+    ...         'language': ['en', 'de', 'fr', 'fr'],
+    ...         'translation': ['the cat', 'die katze', 'la chatte', 'le chat'],
+    ... }
+    ```
+    """
+
+    languages: Optional[List] = None
+    num_languages: Optional[int] = None
+    id: Optional[str] = None
+    # Automatically constructed
+    dtype: ClassVar[str] = "dict"
+    pa_type: ClassVar[Any] = None
+    _type: str = field(default="TranslationVariableLanguages", init=False, repr=False)
+
+    def __post_init__(self):
+        self.languages = sorted(set(self.languages)) if self.languages else None
+        self.num_languages = len(self.languages) if self.languages else None
+
+    def __call__(self):
+        return pa.struct({"language": pa.list_(pa.string()), "translation": pa.list_(pa.string())})
+
+    def encode_example(self, translation_dict):
+        lang_set = set(self.languages)
+        if set(translation_dict) == {"language", "translation"}:
+            return translation_dict
+        elif self.languages and set(translation_dict) - lang_set:
+            raise ValueError(
+                f'Some languages in example ({", ".join(sorted(set(translation_dict) - lang_set))}) are not in valid set ({", ".join(lang_set)}).'
+            )
+
+        # Convert dictionary into tuples, splitting out cases where there are
+        # multiple translations for a single language.
+        translation_tuples = []
+        for lang, text in translation_dict.items():
+            if isinstance(text, str):
+                translation_tuples.append((lang, text))
+            else:
+                translation_tuples.extend([(lang, el) for el in text])
+
+        # Ensure translations are in ascending order by language code.
+        languages, translations = zip(*sorted(translation_tuples))
+
+        return {"language": languages, "translation": translations}
+
+    def flatten(self) -> Union["FeatureType", Dict[str, "FeatureType"]]:
+        """Flatten the TranslationVariableLanguages feature into a dictionary."""
+        from .features import Sequence, Value
+
+        return {
+            "language": Sequence(Value("string")),
+            "translation": Sequence(Value("string")),
+        }

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

@@ -0,0 +1,74 @@
+import itertools
+from dataclasses import dataclass
+from typing import Optional
+
+import pyarrow as pa
+
+import datasets
+from datasets.table import table_cast
+
+
+logger = datasets.utils.logging.get_logger(__name__)
+
+
+@dataclass
+class ArrowConfig(datasets.BuilderConfig):
+    """BuilderConfig for Arrow."""
+
+    features: Optional[datasets.Features] = None
+
+
+class Arrow(datasets.ArrowBasedBuilder):
+    BUILDER_CONFIG_CLASS = ArrowConfig
+
+    def _info(self):
+        return datasets.DatasetInfo(features=self.config.features)
+
+    def _split_generators(self, dl_manager):
+        """We handle string, list and dicts in datafiles"""
+        if not self.config.data_files:
+            raise ValueError(f"At least one data file must be specified, but got data_files={self.config.data_files}")
+        dl_manager.download_config.extract_on_the_fly = True
+        data_files = dl_manager.download_and_extract(self.config.data_files)
+        if isinstance(data_files, (str, list, tuple)):
+            files = data_files
+            if isinstance(files, str):
+                files = [files]
+            # Use `dl_manager.iter_files` to skip hidden files in an extracted archive
+            files = [dl_manager.iter_files(file) for file in files]
+            return [datasets.SplitGenerator(name=datasets.Split.TRAIN, gen_kwargs={"files": files})]
+        splits = []
+        for split_name, files in data_files.items():
+            if isinstance(files, str):
+                files = [files]
+            # Use `dl_manager.iter_files` to skip hidden files in an extracted archive
+            files = [dl_manager.iter_files(file) for file in files]
+            # Infer features is they are stoed in the arrow schema
+            if self.info.features is None:
+                for file in itertools.chain.from_iterable(files):
+                    with open(file, "rb") as f:
+                        self.info.features = datasets.Features.from_arrow_schema(pa.ipc.open_stream(f).schema)
+                    break
+            splits.append(datasets.SplitGenerator(name=split_name, gen_kwargs={"files": files}))
+        return splits
+
+    def _cast_table(self, pa_table: pa.Table) -> pa.Table:
+        if self.info.features is not None:
+            # more expensive cast to support nested features with keys in a different order
+            # allows str <-> int/float or str to Audio for example
+            pa_table = table_cast(pa_table, self.info.features.arrow_schema)
+        return pa_table
+
+    def _generate_tables(self, files):
+        for file_idx, file in enumerate(itertools.chain.from_iterable(files)):
+            with open(file, "rb") as f:
+                try:
+                    for batch_idx, record_batch in enumerate(pa.ipc.open_stream(f)):
+                        pa_table = pa.Table.from_batches([record_batch])
+                        # Uncomment for debugging (will print the Arrow table size and elements)
+                        # logger.warning(f"pa_table: {pa_table} num rows: {pa_table.num_rows}")
+                        # logger.warning('\n'.join(str(pa_table.slice(i, 1).to_pydict()) for i in range(pa_table.num_rows)))
+                        yield f"{file_idx}_{batch_idx}", self._cast_table(pa_table)
+                except ValueError as e:
+                    logger.error(f"Failed to read file '{file}' with error {type(e)}: {e}")
+                    raise

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

@@ -0,0 +1,68 @@
+from typing import List
+
+import datasets
+from datasets.tasks import AudioClassification
+
+from ..folder_based_builder import folder_based_builder
+
+
+logger = datasets.utils.logging.get_logger(__name__)
+
+
+class AudioFolderConfig(folder_based_builder.FolderBasedBuilderConfig):
+    """Builder Config for AudioFolder."""
+
+    drop_labels: bool = None
+    drop_metadata: bool = None
+
+
+class AudioFolder(folder_based_builder.FolderBasedBuilder):
+    BASE_FEATURE = datasets.Audio
+    BASE_COLUMN_NAME = "audio"
+    BUILDER_CONFIG_CLASS = AudioFolderConfig
+    EXTENSIONS: List[str]  # definition at the bottom of the script
+    CLASSIFICATION_TASK = AudioClassification(audio_column="audio", label_column="label")
+
+
+# Obtained with:
+# ```
+# import soundfile as sf
+#
+# AUDIO_EXTENSIONS = [f".{format.lower()}" for format in sf.available_formats().keys()]
+#
+# # .mp3 is currently decoded via `torchaudio`, .opus decoding is supported if version of `libsndfile` >= 1.0.30:
+# AUDIO_EXTENSIONS.extend([".mp3", ".opus"])
+# ```
+# We intentionally do not run this code on launch because:
+# (1) Soundfile is an optional dependency, so importing it in global namespace is not allowed
+# (2) To ensure the list of supported extensions is deterministic
+AUDIO_EXTENSIONS = [
+    ".aiff",
+    ".au",
+    ".avr",
+    ".caf",
+    ".flac",
+    ".htk",
+    ".svx",
+    ".mat4",
+    ".mat5",
+    ".mpc2k",
+    ".ogg",
+    ".paf",
+    ".pvf",
+    ".raw",
+    ".rf64",
+    ".sd2",
+    ".sds",
+    ".ircam",
+    ".voc",
+    ".w64",
+    ".wav",
+    ".nist",
+    ".wavex",
+    ".wve",
+    ".xi",
+    ".mp3",
+    ".opus",
+]
+AudioFolder.EXTENSIONS = AUDIO_EXTENSIONS

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

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

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

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

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

@@ -0,0 +1,27 @@
+# Copyright 2020 The HuggingFace Datasets Authors and the TensorFlow Datasets Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# ruff: noqa
+
+from . import tqdm as _tqdm  # _tqdm is the module
+from .info_utils import VerificationMode
+from .logging import disable_progress_bar, enable_progress_bar, is_progress_bar_enabled
+from .version import Version
+from .experimental import experimental
+from .tqdm import (
+    disable_progress_bars,
+    enable_progress_bars,
+    are_progress_bars_disabled,
+    tqdm,
+)

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

@@ -0,0 +1,96 @@
+from typing import Any, Dict, List, Optional, Union
+
+from .. import config
+from ..exceptions import DatasetsError
+from .file_utils import (
+    get_authentication_headers_for_url,
+    http_get,
+)
+from .logging import get_logger
+
+
+logger = get_logger(__name__)
+
+
+class DatasetViewerError(DatasetsError):
+    """Dataset viewer error.
+
+    Raised when trying to use the dataset viewer HTTP API and when trying to access:
+    - a missing dataset, or
+    - a private/gated dataset and the user is not authenticated.
+    - unavailable /parquet or /info responses
+    """
+
+
+def get_exported_parquet_files(dataset: str, revision: str, token: Optional[Union[str, bool]]) -> List[Dict[str, Any]]:
+    """
+    Get the dataset exported parquet files
+    Docs: https://huggingface.co/docs/datasets-server/parquet
+    """
+    dataset_viewer_parquet_url = config.HF_ENDPOINT.replace("://", "://datasets-server.") + "/parquet?dataset="
+    try:
+        parquet_data_files_response = http_get(
+            url=dataset_viewer_parquet_url + dataset,
+            temp_file=None,
+            headers=get_authentication_headers_for_url(config.HF_ENDPOINT + f"datasets/{dataset}", token=token),
+            timeout=100.0,
+            max_retries=3,
+        )
+        parquet_data_files_response.raise_for_status()
+        if "X-Revision" in parquet_data_files_response.headers:
+            if parquet_data_files_response.headers["X-Revision"] == revision or revision is None:
+                parquet_data_files_response_json = parquet_data_files_response.json()
+                if (
+                    parquet_data_files_response_json.get("partial") is False
+                    and not parquet_data_files_response_json.get("pending", True)
+                    and not parquet_data_files_response_json.get("failed", True)
+                    and "parquet_files" in parquet_data_files_response_json
+                ):
+                    return parquet_data_files_response_json["parquet_files"]
+                else:
+                    logger.debug(f"Parquet export for {dataset} is not completely ready yet.")
+            else:
+                logger.debug(
+                    f"Parquet export for {dataset} is available but outdated (revision='{parquet_data_files_response.headers['X-Revision']}')"
+                )
+    except Exception as e:  # noqa catch any exception of the dataset viewer API and consider the parquet export doesn't exist
+        logger.debug(f"No parquet export for {dataset} available ({type(e).__name__}: {e})")
+    raise DatasetViewerError("No exported Parquet files available.")
+
+
+def get_exported_dataset_infos(
+    dataset: str, revision: str, token: Optional[Union[str, bool]]
+) -> Dict[str, Dict[str, Any]]:
+    """
+    Get the dataset information, can be useful to get e.g. the dataset features.
+    Docs: https://huggingface.co/docs/datasets-server/info
+    """
+    dataset_viewer_info_url = config.HF_ENDPOINT.replace("://", "://datasets-server.") + "/info?dataset="
+    try:
+        info_response = http_get(
+            url=dataset_viewer_info_url + dataset,
+            temp_file=None,
+            headers=get_authentication_headers_for_url(config.HF_ENDPOINT + f"datasets/{dataset}", token=token),
+            timeout=100.0,
+            max_retries=3,
+        )
+        info_response.raise_for_status()
+        if "X-Revision" in info_response.headers:
+            if info_response.headers["X-Revision"] == revision or revision is None:
+                info_response = info_response.json()
+                if (
+                    info_response.get("partial") is False
+                    and not info_response.get("pending", True)
+                    and not info_response.get("failed", True)
+                    and "dataset_info" in info_response
+                ):
+                    return info_response["dataset_info"]
+                else:
+                    logger.debug(f"Dataset info for {dataset} is not completely ready yet.")
+            else:
+                logger.debug(
+                    f"Dataset info for {dataset} is available but outdated (revision='{info_response.headers['X-Revision']}')"
+                )
+    except Exception as e:  # noqa catch any exception of the dataset viewer API and consider the dataset info doesn't exist
+        logger.debug(f"No dataset info for {dataset} available ({type(e).__name__}: {e})")
+    raise DatasetViewerError("No exported dataset infos available.")

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

@@ -0,0 +1,459 @@
+# Copyright 2023 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Extends `dill` to support pickling more types and produce more consistent dumps."""
+
+import os
+import sys
+from io import BytesIO
+from types import CodeType, FunctionType
+
+import dill
+from packaging import version
+
+from .. import config
+
+
+class Pickler(dill.Pickler):
+    dispatch = dill._dill.MetaCatchingDict(dill.Pickler.dispatch.copy())
+    _legacy_no_dict_keys_sorting = False
+
+    def save(self, obj, save_persistent_id=True):
+        obj_type = type(obj)
+        if obj_type not in self.dispatch:
+            if "regex" in sys.modules:
+                import regex  # type: ignore
+
+                if obj_type is regex.Pattern:
+                    pklregister(obj_type)(_save_regexPattern)
+            if "spacy" in sys.modules:
+                import spacy  # type: ignore
+
+                if issubclass(obj_type, spacy.Language):
+                    pklregister(obj_type)(_save_spacyLanguage)
+            if "tiktoken" in sys.modules:
+                import tiktoken  # type: ignore
+
+                if obj_type is tiktoken.Encoding:
+                    pklregister(obj_type)(_save_tiktokenEncoding)
+            if "torch" in sys.modules:
+                import torch  # type: ignore
+
+                if issubclass(obj_type, torch.Tensor):
+                    pklregister(obj_type)(_save_torchTensor)
+
+                if obj_type is torch.Generator:
+                    pklregister(obj_type)(_save_torchGenerator)
+
+                # Unwrap `torch.compile`-ed modules
+                if issubclass(obj_type, torch.nn.Module):
+                    obj = getattr(obj, "_orig_mod", obj)
+            if "transformers" in sys.modules:
+                import transformers  # type: ignore
+
+                if issubclass(obj_type, transformers.PreTrainedTokenizerBase):
+                    pklregister(obj_type)(_save_transformersPreTrainedTokenizerBase)
+
+        # Unwrap `torch.compile`-ed functions
+        if obj_type is FunctionType:
+            obj = getattr(obj, "_torchdynamo_orig_callable", obj)
+        dill.Pickler.save(self, obj, save_persistent_id=save_persistent_id)
+
+    def _batch_setitems(self, items):
+        if self._legacy_no_dict_keys_sorting:
+            return super()._batch_setitems(items)
+        # Ignore the order of keys in a dict
+        try:
+            # Faster, but fails for unorderable elements
+            items = sorted(items)
+        except Exception:  # TypeError, decimal.InvalidOperation, etc.
+            from datasets.fingerprint import Hasher
+
+            items = sorted(items, key=lambda x: Hasher.hash(x[0]))
+        dill.Pickler._batch_setitems(self, items)
+
+    def memoize(self, obj):
+        # Don't memoize strings since two identical strings can have different Python ids
+        if type(obj) is not str:  # noqa: E721
+            dill.Pickler.memoize(self, obj)
+
+
+def pklregister(t):
+    """Register a custom reducer for the type."""
+
+    def proxy(func):
+        Pickler.dispatch[t] = func
+        return func
+
+    return proxy
+
+
+def dump(obj, file):
+    """Pickle an object to a file."""
+    Pickler(file, recurse=True).dump(obj)
+
+
+def dumps(obj):
+    """Pickle an object to a string."""
+    file = BytesIO()
+    dump(obj, file)
+    return file.getvalue()
+
+
+if config.DILL_VERSION < version.parse("0.3.6"):
+
+    def log(pickler, msg):
+        dill._dill.log.info(msg)
+
+elif config.DILL_VERSION.release[:3] in [
+    version.parse("0.3.6").release,
+    version.parse("0.3.7").release,
+    version.parse("0.3.8").release,
+]:
+
+    def log(pickler, msg):
+        dill._dill.logger.trace(pickler, msg)
+
+
+@pklregister(set)
+def _save_set(pickler, obj):
+    log(pickler, f"Se: {obj}")
+    try:
+        # Faster, but fails for unorderable elements
+        args = (sorted(obj),)
+    except Exception:  # TypeError, decimal.InvalidOperation, etc.
+        from datasets.fingerprint import Hasher
+
+        args = (sorted(obj, key=Hasher.hash),)
+
+    pickler.save_reduce(set, args, obj=obj)
+    log(pickler, "# Se")
+
+
+def _save_regexPattern(pickler, obj):
+    import regex  # type: ignore
+
+    log(pickler, f"Re: {obj}")
+    args = (obj.pattern, obj.flags)
+    pickler.save_reduce(regex.compile, args, obj=obj)
+    log(pickler, "# Re")
+
+
+def _save_tiktokenEncoding(pickler, obj):
+    import tiktoken  # type: ignore
+
+    log(pickler, f"Enc: {obj}")
+    args = (obj.name, obj._pat_str, obj._mergeable_ranks, obj._special_tokens)
+    pickler.save_reduce(tiktoken.Encoding, args, obj=obj)
+    log(pickler, "# Enc")
+
+
+def _save_torchTensor(pickler, obj):
+    import torch  # type: ignore
+
+    # `torch.from_numpy` is not picklable in `torch>=1.11.0`
+    def create_torchTensor(np_array):
+        return torch.from_numpy(np_array)
+
+    log(pickler, f"To: {obj}")
+    args = (obj.detach().cpu().numpy(),)
+    pickler.save_reduce(create_torchTensor, args, obj=obj)
+    log(pickler, "# To")
+
+
+def _save_torchGenerator(pickler, obj):
+    import torch  # type: ignore
+
+    def create_torchGenerator(state):
+        generator = torch.Generator()
+        generator.set_state(state)
+        return generator
+
+    log(pickler, f"Ge: {obj}")
+    args = (obj.get_state(),)
+    pickler.save_reduce(create_torchGenerator, args, obj=obj)
+    log(pickler, "# Ge")
+
+
+def _save_spacyLanguage(pickler, obj):
+    import spacy  # type: ignore
+
+    def create_spacyLanguage(config, bytes):
+        lang_cls = spacy.util.get_lang_class(config["nlp"]["lang"])
+        lang_inst = lang_cls.from_config(config)
+        return lang_inst.from_bytes(bytes)
+
+    log(pickler, f"Sp: {obj}")
+    args = (obj.config, obj.to_bytes())
+    pickler.save_reduce(create_spacyLanguage, args, obj=obj)
+    log(pickler, "# Sp")
+
+
+def _save_transformersPreTrainedTokenizerBase(pickler, obj):
+    log(pickler, f"Tok: {obj}")
+    # Ignore the `cache` attribute
+    state = obj.__dict__
+    if "cache" in state and isinstance(state["cache"], dict):
+        state["cache"] = {}
+    pickler.save_reduce(type(obj), (), state=state, obj=obj)
+    log(pickler, "# Tok")
+
+
+if config.DILL_VERSION < version.parse("0.3.6"):
+
+    @pklregister(CodeType)
+    def _save_code(pickler, obj):
+        """
+        From dill._dill.save_code
+        This is a modified version that removes the origin (filename + line no.)
+        of functions created in notebooks or shells for example.
+        """
+        dill._dill.log.info(f"Co: {obj}")
+        # The filename of a function is the .py file where it is defined.
+        # Filenames of functions created in notebooks or shells start with '<'
+        # ex: <ipython-input-13-9ed2afe61d25> for ipython, and <stdin> for shell
+        # Filenames of functions created in ipykernel the filename
+        # look like f"{tempdir}/ipykernel_{id1}/{id2}.py"
+        # Moreover lambda functions have a special name: '<lambda>'
+        # ex: (lambda x: x).__code__.co_name == "<lambda>"  # True
+        #
+        # For the hashing mechanism we ignore where the function has been defined
+        # More specifically:
+        # - we ignore the filename of special functions (filename starts with '<')
+        # - we always ignore the line number
+        # - we only use the base name of the file instead of the whole path,
+        # to be robust in case a script is moved for example.
+        #
+        # Only those two lines are different from the original implementation:
+        co_filename = (
+            ""
+            if obj.co_filename.startswith("<")
+            or (
+                len(obj.co_filename.split(os.path.sep)) > 1
+                and obj.co_filename.split(os.path.sep)[-2].startswith("ipykernel_")
+            )
+            or obj.co_name == "<lambda>"
+            else os.path.basename(obj.co_filename)
+        )
+        co_firstlineno = 1
+        # The rest is the same as in the original dill implementation
+        if dill._dill.PY3:
+            if hasattr(obj, "co_posonlyargcount"):
+                args = (
+                    obj.co_argcount,
+                    obj.co_posonlyargcount,
+                    obj.co_kwonlyargcount,
+                    obj.co_nlocals,
+                    obj.co_stacksize,
+                    obj.co_flags,
+                    obj.co_code,
+                    obj.co_consts,
+                    obj.co_names,
+                    obj.co_varnames,
+                    co_filename,
+                    obj.co_name,
+                    co_firstlineno,
+                    obj.co_lnotab,
+                    obj.co_freevars,
+                    obj.co_cellvars,
+                )
+            else:
+                args = (
+                    obj.co_argcount,
+                    obj.co_kwonlyargcount,
+                    obj.co_nlocals,
+                    obj.co_stacksize,
+                    obj.co_flags,
+                    obj.co_code,
+                    obj.co_consts,
+                    obj.co_names,
+                    obj.co_varnames,
+                    co_filename,
+                    obj.co_name,
+                    co_firstlineno,
+                    obj.co_lnotab,
+                    obj.co_freevars,
+                    obj.co_cellvars,
+                )
+        else:
+            args = (
+                obj.co_argcount,
+                obj.co_nlocals,
+                obj.co_stacksize,
+                obj.co_flags,
+                obj.co_code,
+                obj.co_consts,
+                obj.co_names,
+                obj.co_varnames,
+                co_filename,
+                obj.co_name,
+                co_firstlineno,
+                obj.co_lnotab,
+                obj.co_freevars,
+                obj.co_cellvars,
+            )
+        pickler.save_reduce(CodeType, args, obj=obj)
+        dill._dill.log.info("# Co")
+        return
+
+elif config.DILL_VERSION.release[:3] in [
+    version.parse("0.3.6").release,
+    version.parse("0.3.7").release,
+    version.parse("0.3.8").release,
+]:
+    # From: https://github.com/uqfoundation/dill/blob/dill-0.3.6/dill/_dill.py#L1104
+    @pklregister(CodeType)
+    def save_code(pickler, obj):
+        dill._dill.logger.trace(pickler, "Co: %s", obj)
+
+        ############################################################################################################
+        # Modification here for huggingface/datasets
+        # The filename of a function is the .py file where it is defined.
+        # Filenames of functions created in notebooks or shells start with '<'
+        # ex: <ipython-input-13-9ed2afe61d25> for ipython, and <stdin> for shell
+        # Filenames of functions created in ipykernel the filename
+        # look like f"{tempdir}/ipykernel_{id1}/{id2}.py"
+        # Moreover lambda functions have a special name: '<lambda>'
+        # ex: (lambda x: x).__code__.co_name == "<lambda>"  # True
+        #
+        # For the hashing mechanism we ignore where the function has been defined
+        # More specifically:
+        # - we ignore the filename of special functions (filename starts with '<')
+        # - we always ignore the line number
+        # - we only use the base name of the file instead of the whole path,
+        # to be robust in case a script is moved for example.
+        #
+        # Only those two lines are different from the original implementation:
+        co_filename = (
+            ""
+            if obj.co_filename.startswith("<")
+            or (
+                len(obj.co_filename.split(os.path.sep)) > 1
+                and obj.co_filename.split(os.path.sep)[-2].startswith("ipykernel_")
+            )
+            or obj.co_name == "<lambda>"
+            else os.path.basename(obj.co_filename)
+        )
+        co_firstlineno = 1
+        # The rest is the same as in the original dill implementation, except for the replacements:
+        # - obj.co_filename => co_filename
+        # - obj.co_firstlineno => co_firstlineno
+        ############################################################################################################
+
+        if hasattr(obj, "co_endlinetable"):  # python 3.11a (20 args)
+            args = (
+                obj.co_lnotab,  # for < python 3.10 [not counted in args]
+                obj.co_argcount,
+                obj.co_posonlyargcount,
+                obj.co_kwonlyargcount,
+                obj.co_nlocals,
+                obj.co_stacksize,
+                obj.co_flags,
+                obj.co_code,
+                obj.co_consts,
+                obj.co_names,
+                obj.co_varnames,
+                co_filename,  # Modification for huggingface/datasets ############################################
+                obj.co_name,
+                obj.co_qualname,
+                co_firstlineno,  # Modification for huggingface/datasets #########################################
+                obj.co_linetable,
+                obj.co_endlinetable,
+                obj.co_columntable,
+                obj.co_exceptiontable,
+                obj.co_freevars,
+                obj.co_cellvars,
+            )
+        elif hasattr(obj, "co_exceptiontable"):  # python 3.11 (18 args)
+            args = (
+                obj.co_lnotab,  # for < python 3.10 [not counted in args]
+                obj.co_argcount,
+                obj.co_posonlyargcount,
+                obj.co_kwonlyargcount,
+                obj.co_nlocals,
+                obj.co_stacksize,
+                obj.co_flags,
+                obj.co_code,
+                obj.co_consts,
+                obj.co_names,
+                obj.co_varnames,
+                co_filename,  # Modification for huggingface/datasets ############################################
+                obj.co_name,
+                obj.co_qualname,
+                co_firstlineno,  # Modification for huggingface/datasets #########################################
+                obj.co_linetable,
+                obj.co_exceptiontable,
+                obj.co_freevars,
+                obj.co_cellvars,
+            )
+        elif hasattr(obj, "co_linetable"):  # python 3.10 (16 args)
+            args = (
+                obj.co_lnotab,  # for < python 3.10 [not counted in args]
+                obj.co_argcount,
+                obj.co_posonlyargcount,
+                obj.co_kwonlyargcount,
+                obj.co_nlocals,
+                obj.co_stacksize,
+                obj.co_flags,
+                obj.co_code,
+                obj.co_consts,
+                obj.co_names,
+                obj.co_varnames,
+                co_filename,  # Modification for huggingface/datasets ############################################
+                obj.co_name,
+                co_firstlineno,  # Modification for huggingface/datasets #########################################
+                obj.co_linetable,
+                obj.co_freevars,
+                obj.co_cellvars,
+            )
+        elif hasattr(obj, "co_posonlyargcount"):  # python 3.8 (16 args)
+            args = (
+                obj.co_argcount,
+                obj.co_posonlyargcount,
+                obj.co_kwonlyargcount,
+                obj.co_nlocals,
+                obj.co_stacksize,
+                obj.co_flags,
+                obj.co_code,
+                obj.co_consts,
+                obj.co_names,
+                obj.co_varnames,
+                co_filename,  # Modification for huggingface/datasets ############################################
+                obj.co_name,
+                co_firstlineno,  # Modification for huggingface/datasets #########################################
+                obj.co_lnotab,
+                obj.co_freevars,
+                obj.co_cellvars,
+            )
+        else:  # python 3.7 (15 args)
+            args = (
+                obj.co_argcount,
+                obj.co_kwonlyargcount,
+                obj.co_nlocals,
+                obj.co_stacksize,
+                obj.co_flags,
+                obj.co_code,
+                obj.co_consts,
+                obj.co_names,
+                obj.co_varnames,
+                co_filename,  # Modification for huggingface/datasets ############################################
+                obj.co_name,
+                co_firstlineno,  # Modification for huggingface/datasets #########################################
+                obj.co_lnotab,
+                obj.co_freevars,
+                obj.co_cellvars,
+            )
+
+        pickler.save_reduce(dill._dill._create_code, args, obj=obj)
+        dill._dill.logger.trace(pickler, "# Co")
+        return

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

@@ -0,0 +1,59 @@
+#!/usr/bin/env python
+# coding=utf-8
+# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License
+"""Utilities to handle file locking in `datasets`."""
+
+import os
+
+from filelock import FileLock as FileLock_
+from filelock import UnixFileLock
+from filelock import __version__ as _filelock_version
+from packaging import version
+
+
+class FileLock(FileLock_):
+    """
+    A `filelock.FileLock` initializer that handles long paths.
+    It also uses the current umask for lock files.
+    """
+
+    MAX_FILENAME_LENGTH = 255
+
+    def __init__(self, lock_file, *args, **kwargs):
+        # The "mode" argument is required if we want to use the current umask in filelock >= 3.10
+        # In previous previous it was already using the current umask.
+        if "mode" not in kwargs and version.parse(_filelock_version) >= version.parse("3.10.0"):
+            umask = os.umask(0o666)
+            os.umask(umask)
+            kwargs["mode"] = 0o666 & ~umask
+        lock_file = self.hash_filename_if_too_long(lock_file)
+        super().__init__(lock_file, *args, **kwargs)
+
+    @classmethod
+    def hash_filename_if_too_long(cls, path: str) -> str:
+        path = os.path.abspath(os.path.expanduser(path))
+        filename = os.path.basename(path)
+        max_filename_length = cls.MAX_FILENAME_LENGTH
+        if issubclass(cls, UnixFileLock):
+            max_filename_length = min(max_filename_length, os.statvfs(os.path.dirname(path)).f_namemax)
+        if len(filename) > max_filename_length:
+            dirname = os.path.dirname(path)
+            hashed_filename = str(hash(filename))
+            new_filename = (
+                filename[: max_filename_length - len(hashed_filename) - 8] + "..." + hashed_filename + ".lock"
+            )
+            return os.path.join(dirname, new_filename)
+        else:
+            return path