Add files using upload-large-folder tool

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

@@ -0,0 +1,139 @@
+# Copyright 2020 The HuggingFace Datasets Authors and the TensorFlow Datasets Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# ruff: noqa
+
+from typing import Dict, List, Optional, Type
+
+from .. import config
+from ..utils import logging
+from .formatting import (
+    ArrowFormatter,
+    CustomFormatter,
+    Formatter,
+    PandasFormatter,
+    PythonFormatter,
+    TensorFormatter,
+    format_table,
+    query_table,
+)
+from .np_formatter import NumpyFormatter
+
+
+logger = logging.get_logger(__name__)
+
+_FORMAT_TYPES: Dict[Optional[str], Type[Formatter]] = {}
+_FORMAT_TYPES_ALIASES: Dict[Optional[str], str] = {}
+_FORMAT_TYPES_ALIASES_UNAVAILABLE: Dict[Optional[str], Exception] = {}
+
+
+def _register_formatter(
+    formatter_cls: type,
+    format_type: Optional[str],
+    aliases: Optional[List[str]] = None,
+):
+    """
+    Register a Formatter object using a name and optional aliases.
+    This function must be used on a Formatter class.
+    """
+    aliases = aliases if aliases is not None else []
+    if format_type in _FORMAT_TYPES:
+        logger.warning(
+            f"Overwriting format type '{format_type}' ({_FORMAT_TYPES[format_type].__name__} -> {formatter_cls.__name__})"
+        )
+    _FORMAT_TYPES[format_type] = formatter_cls
+    for alias in set(aliases + [format_type]):
+        if alias in _FORMAT_TYPES_ALIASES:
+            logger.warning(
+                f"Overwriting format type alias '{alias}' ({_FORMAT_TYPES_ALIASES[alias]} -> {format_type})"
+            )
+        _FORMAT_TYPES_ALIASES[alias] = format_type
+
+
+def _register_unavailable_formatter(
+    unavailable_error: Exception, format_type: Optional[str], aliases: Optional[List[str]] = None
+):
+    """
+    Register an unavailable Formatter object using a name and optional aliases.
+    This function must be used on an Exception object that is raised when trying to get the unavailable formatter.
+    """
+    aliases = aliases if aliases is not None else []
+    for alias in set(aliases + [format_type]):
+        _FORMAT_TYPES_ALIASES_UNAVAILABLE[alias] = unavailable_error
+
+
+# Here we define all the available formatting functions that can be used by `Dataset.set_format`
+_register_formatter(PythonFormatter, None, aliases=["python"])
+_register_formatter(ArrowFormatter, "arrow", aliases=["pa", "pyarrow"])
+_register_formatter(NumpyFormatter, "numpy", aliases=["np"])
+_register_formatter(PandasFormatter, "pandas", aliases=["pd"])
+_register_formatter(CustomFormatter, "custom")
+
+if config.POLARS_AVAILABLE:
+    from .polars_formatter import PolarsFormatter
+
+    _register_formatter(PolarsFormatter, "polars", aliases=["pl"])
+else:
+    _polars_error = ValueError("Polars needs to be installed to be able to return Polars dataframes.")
+    _register_unavailable_formatter(_polars_error, "polars", aliases=["pl"])
+
+if config.TORCH_AVAILABLE:
+    from .torch_formatter import TorchFormatter
+
+    _register_formatter(TorchFormatter, "torch", aliases=["pt", "pytorch"])
+else:
+    _torch_error = ValueError("PyTorch needs to be installed to be able to return PyTorch tensors.")
+    _register_unavailable_formatter(_torch_error, "torch", aliases=["pt", "pytorch"])
+
+if config.TF_AVAILABLE:
+    from .tf_formatter import TFFormatter
+
+    _register_formatter(TFFormatter, "tensorflow", aliases=["tf"])
+else:
+    _tf_error = ValueError("Tensorflow needs to be installed to be able to return Tensorflow tensors.")
+    _register_unavailable_formatter(_tf_error, "tensorflow", aliases=["tf"])
+
+if config.JAX_AVAILABLE:
+    from .jax_formatter import JaxFormatter
+
+    _register_formatter(JaxFormatter, "jax", aliases=[])
+else:
+    _jax_error = ValueError("JAX needs to be installed to be able to return JAX arrays.")
+    _register_unavailable_formatter(_jax_error, "jax", aliases=[])
+
+
+def get_format_type_from_alias(format_type: Optional[str]) -> Optional[str]:
+    """If the given format type is a known alias, then return its main type name. Otherwise return the type with no change."""
+    if format_type in _FORMAT_TYPES_ALIASES:
+        return _FORMAT_TYPES_ALIASES[format_type]
+    else:
+        return format_type
+
+
+def get_formatter(format_type: Optional[str], **format_kwargs) -> Formatter:
+    """
+    Factory function to get a Formatter given its type name and keyword arguments.
+    A formatter is an object that extracts and formats data from pyarrow table.
+    It defines the formatting for rows, colums and batches.
+    If the formatter for a given type name doesn't exist or is not available, an error is raised.
+    """
+    format_type = get_format_type_from_alias(format_type)
+    if format_type in _FORMAT_TYPES:
+        return _FORMAT_TYPES[format_type](**format_kwargs)
+    if format_type in _FORMAT_TYPES_ALIASES_UNAVAILABLE:
+        raise _FORMAT_TYPES_ALIASES_UNAVAILABLE[format_type]
+    else:
+        raise ValueError(
+            f"Return type should be None or selected in {list(type for type in _FORMAT_TYPES.keys() if type != None)}, but got '{format_type}'"
+        )

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

@@ -0,0 +1,653 @@
+# Copyright 2020 The HuggingFace Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import operator
+from collections.abc import Mapping, MutableMapping
+from functools import partial
+
+# Lint as: python3
+from typing import Any, Callable, Dict, Generic, Iterable, List, Optional, TypeVar, Union
+
+import numpy as np
+import pandas as pd
+import pyarrow as pa
+from packaging import version
+
+from .. import config
+from ..features import Features
+from ..features.features import _ArrayXDExtensionType, _is_zero_copy_only, decode_nested_example, pandas_types_mapper
+from ..table import Table
+from ..utils.py_utils import no_op_if_value_is_null
+
+
+T = TypeVar("T")
+
+RowFormat = TypeVar("RowFormat")
+ColumnFormat = TypeVar("ColumnFormat")
+BatchFormat = TypeVar("BatchFormat")
+
+
+def _is_range_contiguous(key: range) -> bool:
+    return key.step == 1 and key.stop >= key.start
+
+
+def _raise_bad_key_type(key: Any):
+    raise TypeError(
+        f"Wrong key type: '{key}' of type '{type(key)}'. Expected one of int, slice, range, str or Iterable."
+    )
+
+
+def _query_table_with_indices_mapping(
+    table: Table, key: Union[int, slice, range, str, Iterable], indices: Table
+) -> pa.Table:
+    """
+    Query a pyarrow Table to extract the subtable that correspond to the given key.
+    The :obj:`indices` parameter corresponds to the indices mapping in case we cant to take into
+    account a shuffling or an indices selection for example.
+    The indices table must contain one column named "indices" of type uint64.
+    """
+    if isinstance(key, int):
+        key = indices.fast_slice(key % indices.num_rows, 1).column(0)[0].as_py()
+        return _query_table(table, key)
+    if isinstance(key, slice):
+        key = range(*key.indices(indices.num_rows))
+    if isinstance(key, range):
+        if _is_range_contiguous(key) and key.start >= 0:
+            return _query_table(
+                table, [i.as_py() for i in indices.fast_slice(key.start, key.stop - key.start).column(0)]
+            )
+        else:
+            pass  # treat as an iterable
+    if isinstance(key, str):
+        table = table.select([key])
+        return _query_table(table, indices.column(0).to_pylist())
+    if isinstance(key, Iterable):
+        return _query_table(table, [indices.fast_slice(i, 1).column(0)[0].as_py() for i in key])
+
+    _raise_bad_key_type(key)
+
+
+def _query_table(table: Table, key: Union[int, slice, range, str, Iterable]) -> pa.Table:
+    """
+    Query a pyarrow Table to extract the subtable that correspond to the given key.
+    """
+    if isinstance(key, int):
+        return table.fast_slice(key % table.num_rows, 1)
+    if isinstance(key, slice):
+        key = range(*key.indices(table.num_rows))
+    if isinstance(key, range):
+        if _is_range_contiguous(key) and key.start >= 0:
+            return table.fast_slice(key.start, key.stop - key.start)
+        else:
+            pass  # treat as an iterable
+    if isinstance(key, str):
+        return table.table.drop([column for column in table.column_names if column != key])
+    if isinstance(key, Iterable):
+        key = np.fromiter(key, np.int64)
+        if len(key) == 0:
+            return table.table.slice(0, 0)
+        # don't use pyarrow.Table.take even for pyarrow >=1.0 (see https://issues.apache.org/jira/browse/ARROW-9773)
+        return table.fast_gather(key % table.num_rows)
+
+    _raise_bad_key_type(key)
+
+
+def _is_array_with_nulls(pa_array: pa.Array) -> bool:
+    return pa_array.null_count > 0
+
+
+class BaseArrowExtractor(Generic[RowFormat, ColumnFormat, BatchFormat]):
+    """
+    Arrow extractor are used to extract data from pyarrow tables.
+    It makes it possible to extract rows, columns and batches.
+    These three extractions types have to be implemented.
+    """
+
+    def extract_row(self, pa_table: pa.Table) -> RowFormat:
+        raise NotImplementedError
+
+    def extract_column(self, pa_table: pa.Table) -> ColumnFormat:
+        raise NotImplementedError
+
+    def extract_batch(self, pa_table: pa.Table) -> BatchFormat:
+        raise NotImplementedError
+
+
+def _unnest(py_dict: Dict[str, List[T]]) -> Dict[str, T]:
+    """Return the first element of a batch (dict) as a row (dict)"""
+    return {key: array[0] for key, array in py_dict.items()}
+
+
+class SimpleArrowExtractor(BaseArrowExtractor[pa.Table, pa.Array, pa.Table]):
+    def extract_row(self, pa_table: pa.Table) -> pa.Table:
+        return pa_table
+
+    def extract_column(self, pa_table: pa.Table) -> pa.Array:
+        return pa_table.column(0)
+
+    def extract_batch(self, pa_table: pa.Table) -> pa.Table:
+        return pa_table
+
+
+class PythonArrowExtractor(BaseArrowExtractor[dict, list, dict]):
+    def extract_row(self, pa_table: pa.Table) -> dict:
+        return _unnest(pa_table.to_pydict())
+
+    def extract_column(self, pa_table: pa.Table) -> list:
+        return pa_table.column(0).to_pylist()
+
+    def extract_batch(self, pa_table: pa.Table) -> dict:
+        return pa_table.to_pydict()
+
+
+class NumpyArrowExtractor(BaseArrowExtractor[dict, np.ndarray, dict]):
+    def __init__(self, **np_array_kwargs):
+        self.np_array_kwargs = np_array_kwargs
+
+    def extract_row(self, pa_table: pa.Table) -> dict:
+        return _unnest(self.extract_batch(pa_table))
+
+    def extract_column(self, pa_table: pa.Table) -> np.ndarray:
+        return self._arrow_array_to_numpy(pa_table[pa_table.column_names[0]])
+
+    def extract_batch(self, pa_table: pa.Table) -> dict:
+        return {col: self._arrow_array_to_numpy(pa_table[col]) for col in pa_table.column_names}
+
+    def _arrow_array_to_numpy(self, pa_array: pa.Array) -> np.ndarray:
+        if isinstance(pa_array, pa.ChunkedArray):
+            if isinstance(pa_array.type, _ArrayXDExtensionType):
+                # don't call to_pylist() to preserve dtype of the fixed-size array
+                zero_copy_only = _is_zero_copy_only(pa_array.type.storage_dtype, unnest=True)
+                array: List = [
+                    row for chunk in pa_array.chunks for row in chunk.to_numpy(zero_copy_only=zero_copy_only)
+                ]
+            else:
+                zero_copy_only = _is_zero_copy_only(pa_array.type) and all(
+                    not _is_array_with_nulls(chunk) for chunk in pa_array.chunks
+                )
+                array: List = [
+                    row for chunk in pa_array.chunks for row in chunk.to_numpy(zero_copy_only=zero_copy_only)
+                ]
+        else:
+            if isinstance(pa_array.type, _ArrayXDExtensionType):
+                # don't call to_pylist() to preserve dtype of the fixed-size array
+                zero_copy_only = _is_zero_copy_only(pa_array.type.storage_dtype, unnest=True)
+                array: List = pa_array.to_numpy(zero_copy_only=zero_copy_only)
+            else:
+                zero_copy_only = _is_zero_copy_only(pa_array.type) and not _is_array_with_nulls(pa_array)
+                array: List = pa_array.to_numpy(zero_copy_only=zero_copy_only).tolist()
+        if len(array) > 0:
+            if any(
+                (isinstance(x, np.ndarray) and (x.dtype == object or x.shape != array[0].shape))
+                or (isinstance(x, float) and np.isnan(x))
+                for x in array
+            ):
+                return np.array(array, copy=False, dtype=object)
+        return np.array(array, copy=False)
+
+
+class PandasArrowExtractor(BaseArrowExtractor[pd.DataFrame, pd.Series, pd.DataFrame]):
+    def extract_row(self, pa_table: pa.Table) -> pd.DataFrame:
+        return pa_table.slice(length=1).to_pandas(types_mapper=pandas_types_mapper)
+
+    def extract_column(self, pa_table: pa.Table) -> pd.Series:
+        return pa_table.select([0]).to_pandas(types_mapper=pandas_types_mapper)[pa_table.column_names[0]]
+
+    def extract_batch(self, pa_table: pa.Table) -> pd.DataFrame:
+        return pa_table.to_pandas(types_mapper=pandas_types_mapper)
+
+
+class PythonFeaturesDecoder:
+    def __init__(self, features: Optional[Features]):
+        self.features = features
+
+    def decode_row(self, row: dict) -> dict:
+        return self.features.decode_example(row) if self.features else row
+
+    def decode_column(self, column: list, column_name: str) -> list:
+        return self.features.decode_column(column, column_name) if self.features else column
+
+    def decode_batch(self, batch: dict) -> dict:
+        return self.features.decode_batch(batch) if self.features else batch
+
+
+class PandasFeaturesDecoder:
+    def __init__(self, features: Optional[Features]):
+        self.features = features
+
+    def decode_row(self, row: pd.DataFrame) -> pd.DataFrame:
+        decode = (
+            {
+                column_name: no_op_if_value_is_null(partial(decode_nested_example, feature))
+                for column_name, feature in self.features.items()
+                if self.features._column_requires_decoding[column_name]
+            }
+            if self.features
+            else {}
+        )
+        if decode:
+            row[list(decode.keys())] = row.transform(decode)
+        return row
+
+    def decode_column(self, column: pd.Series, column_name: str) -> pd.Series:
+        decode = (
+            no_op_if_value_is_null(partial(decode_nested_example, self.features[column_name]))
+            if self.features and column_name in self.features and self.features._column_requires_decoding[column_name]
+            else None
+        )
+        if decode:
+            column = column.transform(decode)
+        return column
+
+    def decode_batch(self, batch: pd.DataFrame) -> pd.DataFrame:
+        return self.decode_row(batch)
+
+
+class LazyDict(MutableMapping):
+    """A dictionary backed by Arrow data. The values are formatted on-the-fly when accessing the dictionary."""
+
+    def __init__(self, pa_table: pa.Table, formatter: "Formatter"):
+        self.pa_table = pa_table
+        self.formatter = formatter
+
+        self.data = {key: None for key in pa_table.column_names}
+        self.keys_to_format = set(self.data.keys())
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, key):
+        value = self.data[key]
+        if key in self.keys_to_format:
+            value = self.format(key)
+            self.data[key] = value
+            self.keys_to_format.remove(key)
+        return value
+
+    def __setitem__(self, key, value):
+        if key in self.keys_to_format:
+            self.keys_to_format.remove(key)
+        self.data[key] = value
+
+    def __delitem__(self, key) -> None:
+        if key in self.keys_to_format:
+            self.keys_to_format.remove(key)
+        del self.data[key]
+
+    def __iter__(self):
+        return iter(self.data)
+
+    def __contains__(self, key):
+        return key in self.data
+
+    def __repr__(self):
+        self._format_all()
+        return repr(self.data)
+
+    if config.PY_VERSION >= version.parse("3.9"):
+        # merging with the union ("|") operator is supported in Python 3.9+
+
+        def __or__(self, other):
+            if isinstance(other, LazyDict):
+                inst = self.copy()
+                other = other.copy()
+                other._format_all()
+                inst.keys_to_format -= other.data.keys()
+                inst.data = inst.data | other.data
+                return inst
+            if isinstance(other, dict):
+                inst = self.copy()
+                inst.keys_to_format -= other.keys()
+                inst.data = inst.data | other
+                return inst
+            return NotImplemented
+
+        def __ror__(self, other):
+            if isinstance(other, LazyDict):
+                inst = self.copy()
+                other = other.copy()
+                other._format_all()
+                inst.keys_to_format -= other.data.keys()
+                inst.data = other.data | inst.data
+                return inst
+            if isinstance(other, dict):
+                inst = self.copy()
+                inst.keys_to_format -= other.keys()
+                inst.data = other | inst.data
+                return inst
+            return NotImplemented
+
+        def __ior__(self, other):
+            if isinstance(other, LazyDict):
+                other = other.copy()
+                other._format_all()
+                self.keys_to_format -= other.data.keys()
+                self.data |= other.data
+            else:
+                self.keys_to_format -= other.keys()
+                self.data |= other
+            return self
+
+    def __copy__(self):
+        # Identical to `UserDict.__copy__`
+        inst = self.__class__.__new__(self.__class__)
+        inst.__dict__.update(self.__dict__)
+        # Create a copy and avoid triggering descriptors
+        inst.__dict__["data"] = self.__dict__["data"].copy()
+        inst.__dict__["keys_to_format"] = self.__dict__["keys_to_format"].copy()
+        return inst
+
+    def copy(self):
+        import copy
+
+        return copy.copy(self)
+
+    @classmethod
+    def fromkeys(cls, iterable, value=None):
+        raise NotImplementedError
+
+    def format(self, key):
+        raise NotImplementedError
+
+    def _format_all(self):
+        for key in self.keys_to_format:
+            self.data[key] = self.format(key)
+        self.keys_to_format.clear()
+
+
+class LazyRow(LazyDict):
+    def format(self, key):
+        return self.formatter.format_column(self.pa_table.select([key]))[0]
+
+
+class LazyBatch(LazyDict):
+    def format(self, key):
+        return self.formatter.format_column(self.pa_table.select([key]))
+
+
+class Formatter(Generic[RowFormat, ColumnFormat, BatchFormat]):
+    """
+    A formatter is an object that extracts and formats data from pyarrow tables.
+    It defines the formatting for rows, columns and batches.
+    """
+
+    simple_arrow_extractor = SimpleArrowExtractor
+    python_arrow_extractor = PythonArrowExtractor
+    numpy_arrow_extractor = NumpyArrowExtractor
+    pandas_arrow_extractor = PandasArrowExtractor
+
+    def __init__(self, features: Optional[Features] = None):
+        self.features = features
+        self.python_features_decoder = PythonFeaturesDecoder(self.features)
+        self.pandas_features_decoder = PandasFeaturesDecoder(self.features)
+
+    def __call__(self, pa_table: pa.Table, query_type: str) -> Union[RowFormat, ColumnFormat, BatchFormat]:
+        if query_type == "row":
+            return self.format_row(pa_table)
+        elif query_type == "column":
+            return self.format_column(pa_table)
+        elif query_type == "batch":
+            return self.format_batch(pa_table)
+
+    def format_row(self, pa_table: pa.Table) -> RowFormat:
+        raise NotImplementedError
+
+    def format_column(self, pa_table: pa.Table) -> ColumnFormat:
+        raise NotImplementedError
+
+    def format_batch(self, pa_table: pa.Table) -> BatchFormat:
+        raise NotImplementedError
+
+
+class TensorFormatter(Formatter[RowFormat, ColumnFormat, BatchFormat]):
+    def recursive_tensorize(self, data_struct: dict):
+        raise NotImplementedError
+
+
+class ArrowFormatter(Formatter[pa.Table, pa.Array, pa.Table]):
+    def format_row(self, pa_table: pa.Table) -> pa.Table:
+        return self.simple_arrow_extractor().extract_row(pa_table)
+
+    def format_column(self, pa_table: pa.Table) -> pa.Array:
+        return self.simple_arrow_extractor().extract_column(pa_table)
+
+    def format_batch(self, pa_table: pa.Table) -> pa.Table:
+        return self.simple_arrow_extractor().extract_batch(pa_table)
+
+
+class PythonFormatter(Formatter[Mapping, list, Mapping]):
+    def __init__(self, features=None, lazy=False):
+        super().__init__(features)
+        self.lazy = lazy
+
+    def format_row(self, pa_table: pa.Table) -> Mapping:
+        if self.lazy:
+            return LazyRow(pa_table, self)
+        row = self.python_arrow_extractor().extract_row(pa_table)
+        row = self.python_features_decoder.decode_row(row)
+        return row
+
+    def format_column(self, pa_table: pa.Table) -> list:
+        column = self.python_arrow_extractor().extract_column(pa_table)
+        column = self.python_features_decoder.decode_column(column, pa_table.column_names[0])
+        return column
+
+    def format_batch(self, pa_table: pa.Table) -> Mapping:
+        if self.lazy:
+            return LazyBatch(pa_table, self)
+        batch = self.python_arrow_extractor().extract_batch(pa_table)
+        batch = self.python_features_decoder.decode_batch(batch)
+        return batch
+
+
+class PandasFormatter(Formatter[pd.DataFrame, pd.Series, pd.DataFrame]):
+    def format_row(self, pa_table: pa.Table) -> pd.DataFrame:
+        row = self.pandas_arrow_extractor().extract_row(pa_table)
+        row = self.pandas_features_decoder.decode_row(row)
+        return row
+
+    def format_column(self, pa_table: pa.Table) -> pd.Series:
+        column = self.pandas_arrow_extractor().extract_column(pa_table)
+        column = self.pandas_features_decoder.decode_column(column, pa_table.column_names[0])
+        return column
+
+    def format_batch(self, pa_table: pa.Table) -> pd.DataFrame:
+        row = self.pandas_arrow_extractor().extract_batch(pa_table)
+        row = self.pandas_features_decoder.decode_batch(row)
+        return row
+
+
+class CustomFormatter(Formatter[dict, ColumnFormat, dict]):
+    """
+    A user-defined custom formatter function defined by a ``transform``.
+    The transform must take as input a batch of data extracted for an arrow table using the python extractor,
+    and return a batch.
+    If the output batch is not a dict, then output_all_columns won't work.
+    If the ouput batch has several fields, then querying a single column won't work since we don't know which field
+    to return.
+    """
+
+    def __init__(self, transform: Callable[[dict], dict], features=None, **kwargs):
+        super().__init__(features=features)
+        self.transform = transform
+
+    def format_row(self, pa_table: pa.Table) -> dict:
+        formatted_batch = self.format_batch(pa_table)
+        try:
+            return _unnest(formatted_batch)
+        except Exception as exc:
+            raise TypeError(
+                f"Custom formatting function must return a dict of sequences to be able to pick a row, but got {formatted_batch}"
+            ) from exc
+
+    def format_column(self, pa_table: pa.Table) -> ColumnFormat:
+        formatted_batch = self.format_batch(pa_table)
+        if hasattr(formatted_batch, "keys"):
+            if len(formatted_batch.keys()) > 1:
+                raise TypeError(
+                    "Tried to query a column but the custom formatting function returns too many columns. "
+                    f"Only one column was expected but got columns {list(formatted_batch.keys())}."
+                )
+        else:
+            raise TypeError(
+                f"Custom formatting function must return a dict to be able to pick a row, but got {formatted_batch}"
+            )
+        try:
+            return formatted_batch[pa_table.column_names[0]]
+        except Exception as exc:
+            raise TypeError(
+                f"Custom formatting function must return a dict to be able to pick a row, but got {formatted_batch}"
+            ) from exc
+
+    def format_batch(self, pa_table: pa.Table) -> dict:
+        batch = self.python_arrow_extractor().extract_batch(pa_table)
+        batch = self.python_features_decoder.decode_batch(batch)
+        return self.transform(batch)
+
+
+def _check_valid_column_key(key: str, columns: List[str]) -> None:
+    if key not in columns:
+        raise KeyError(f"Column {key} not in the dataset. Current columns in the dataset: {columns}")
+
+
+def _check_valid_index_key(key: Union[int, slice, range, Iterable], size: int) -> None:
+    if isinstance(key, int):
+        if (key < 0 and key + size < 0) or (key >= size):
+            raise IndexError(f"Invalid key: {key} is out of bounds for size {size}")
+        return
+    elif isinstance(key, slice):
+        pass
+    elif isinstance(key, range):
+        if len(key) > 0:
+            _check_valid_index_key(max(key), size=size)
+            _check_valid_index_key(min(key), size=size)
+    elif isinstance(key, Iterable):
+        if len(key) > 0:
+            _check_valid_index_key(int(max(key)), size=size)
+            _check_valid_index_key(int(min(key)), size=size)
+    else:
+        _raise_bad_key_type(key)
+
+
+def key_to_query_type(key: Union[int, slice, range, str, Iterable]) -> str:
+    if isinstance(key, int):
+        return "row"
+    elif isinstance(key, str):
+        return "column"
+    elif isinstance(key, (slice, range, Iterable)):
+        return "batch"
+    _raise_bad_key_type(key)
+
+
+def query_table(
+    table: Table,
+    key: Union[int, slice, range, str, Iterable],
+    indices: Optional[Table] = None,
+) -> pa.Table:
+    """
+    Query a Table to extract the subtable that correspond to the given key.
+
+    Args:
+        table (``datasets.table.Table``): The input Table to query from
+        key (``Union[int, slice, range, str, Iterable]``): The key can be of different types:
+            - an integer i: the subtable containing only the i-th row
+            - a slice [i:j:k]: the subtable containing the rows that correspond to this slice
+            - a range(i, j, k): the subtable containing the rows that correspond to this range
+            - a string c: the subtable containing all the rows but only the column c
+            - an iterable l: the subtable that is the concatenation of all the i-th rows for all i in the iterable
+        indices (Optional ``datasets.table.Table``): If not None, it is used to re-map the given key to the table rows.
+            The indices table must contain one column named "indices" of type uint64.
+            This is used in case of shuffling or rows selection.
+
+
+    Returns:
+        ``pyarrow.Table``: the result of the query on the input table
+    """
+    # Check if key is valid
+    if not isinstance(key, (int, slice, range, str, Iterable)):
+        try:
+            key = operator.index(key)
+        except TypeError:
+            _raise_bad_key_type(key)
+    if isinstance(key, str):
+        _check_valid_column_key(key, table.column_names)
+    else:
+        size = indices.num_rows if indices is not None else table.num_rows
+        _check_valid_index_key(key, size)
+    # Query the main table
+    if indices is None:
+        pa_subtable = _query_table(table, key)
+    else:
+        pa_subtable = _query_table_with_indices_mapping(table, key, indices=indices)
+    return pa_subtable
+
+
+def format_table(
+    table: Table,
+    key: Union[int, slice, range, str, Iterable],
+    formatter: Formatter,
+    format_columns: Optional[list] = None,
+    output_all_columns=False,
+):
+    """
+    Format a Table depending on the key that was used and a Formatter object.
+
+    Args:
+        table (``datasets.table.Table``): The input Table to format
+        key (``Union[int, slice, range, str, Iterable]``): Depending on the key that was used, the formatter formats
+            the table as either a row, a column or a batch.
+        formatter (``datasets.formatting.formatting.Formatter``): Any subclass of a Formatter such as
+            PythonFormatter, NumpyFormatter, etc.
+        format_columns (:obj:`List[str]`, optional): if not None, it defines the columns that will be formatted using the
+            given formatter. Other columns are discarded (unless ``output_all_columns`` is True)
+        output_all_columns (:obj:`bool`, defaults to False). If True, the formatted output is completed using the columns
+            that are not in the ``format_columns`` list. For these columns, the PythonFormatter is used.
+
+
+    Returns:
+        A row, column or batch formatted object defined by the Formatter:
+        - the PythonFormatter returns a dictionary for a row or a batch, and a list for a column.
+        - the NumpyFormatter returns a dictionary for a row or a batch, and a np.array for a column.
+        - the PandasFormatter returns a pd.DataFrame for a row or a batch, and a pd.Series for a column.
+        - the TorchFormatter returns a dictionary for a row or a batch, and a torch.Tensor for a column.
+        - the TFFormatter returns a dictionary for a row or a batch, and a tf.Tensor for a column.
+    """
+    if isinstance(table, Table):
+        pa_table = table.table
+    else:
+        pa_table = table
+    query_type = key_to_query_type(key)
+    python_formatter = PythonFormatter(features=formatter.features)
+    if format_columns is None:
+        return formatter(pa_table, query_type=query_type)
+    elif query_type == "column":
+        if key in format_columns:
+            return formatter(pa_table, query_type)
+        else:
+            return python_formatter(pa_table, query_type=query_type)
+    else:
+        pa_table_to_format = pa_table.drop(col for col in pa_table.column_names if col not in format_columns)
+        formatted_output = formatter(pa_table_to_format, query_type=query_type)
+        if output_all_columns:
+            if isinstance(formatted_output, MutableMapping):
+                pa_table_with_remaining_columns = pa_table.drop(
+                    col for col in pa_table.column_names if col in format_columns
+                )
+                remaining_columns_dict = python_formatter(pa_table_with_remaining_columns, query_type=query_type)
+                formatted_output.update(remaining_columns_dict)
+            else:
+                raise TypeError(
+                    f"Custom formatting function must return a dict to work with output_all_columns=True, but got {formatted_output}"
+                )
+        return formatted_output

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

@@ -0,0 +1,160 @@
+# Copyright 2021 The HuggingFace Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Lint as: python3
+import sys
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Dict, Optional
+
+import numpy as np
+import pyarrow as pa
+
+from .. import config
+from ..utils.logging import get_logger
+from ..utils.py_utils import map_nested
+from .formatting import TensorFormatter
+
+
+if TYPE_CHECKING:
+    import jax
+    import jaxlib
+
+logger = get_logger()
+
+DEVICE_MAPPING: Optional[dict] = None
+
+
+class JaxFormatter(TensorFormatter[Mapping, "jax.Array", Mapping]):
+    def __init__(self, features=None, device=None, **jnp_array_kwargs):
+        super().__init__(features=features)
+        import jax
+        from jaxlib.xla_client import Device
+
+        if isinstance(device, Device):
+            raise ValueError(
+                f"Expected {device} to be a `str` not {type(device)}, as `jaxlib.xla_extension.Device` "
+                "is not serializable neither with `pickle` nor with `dill`. Instead you can surround "
+                "the device with `str()` to get its string identifier that will be internally mapped "
+                "to the actual `jaxlib.xla_extension.Device`."
+            )
+        self.device = device if isinstance(device, str) else str(jax.devices()[0])
+        # using global variable since `jaxlib.xla_extension.Device` is not serializable neither
+        # with `pickle` nor with `dill`, so we need to use a global variable instead
+        global DEVICE_MAPPING
+        if DEVICE_MAPPING is None:
+            DEVICE_MAPPING = self._map_devices_to_str()
+        if self.device not in list(DEVICE_MAPPING.keys()):
+            logger.warning(
+                f"Device with string identifier {self.device} not listed among the available "
+                f"devices: {list(DEVICE_MAPPING.keys())}, so falling back to the default "
+                f"device: {str(jax.devices()[0])}."
+            )
+            self.device = str(jax.devices()[0])
+        self.jnp_array_kwargs = jnp_array_kwargs
+
+    @staticmethod
+    def _map_devices_to_str() -> Dict[str, "jaxlib.xla_extension.Device"]:
+        import jax
+
+        return {str(device): device for device in jax.devices()}
+
+    def _consolidate(self, column):
+        import jax
+        import jax.numpy as jnp
+
+        if isinstance(column, list) and column:
+            if all(
+                isinstance(x, jax.Array) and x.shape == column[0].shape and x.dtype == column[0].dtype for x in column
+            ):
+                return jnp.stack(column, axis=0)
+        return column
+
+    def _tensorize(self, value):
+        import jax
+        import jax.numpy as jnp
+
+        if isinstance(value, (str, bytes, type(None))):
+            return value
+        elif isinstance(value, (np.character, np.ndarray)) and np.issubdtype(value.dtype, np.character):
+            return value.tolist()
+
+        default_dtype = {}
+
+        if isinstance(value, (np.number, np.ndarray)) and np.issubdtype(value.dtype, np.integer):
+            # the default int precision depends on the jax config
+            # see https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#double-64bit-precision
+            if jax.config.jax_enable_x64:
+                default_dtype = {"dtype": jnp.int64}
+            else:
+                default_dtype = {"dtype": jnp.int32}
+        elif isinstance(value, (np.number, np.ndarray)) and np.issubdtype(value.dtype, np.floating):
+            default_dtype = {"dtype": jnp.float32}
+        elif config.PIL_AVAILABLE and "PIL" in sys.modules:
+            import PIL.Image
+
+            if isinstance(value, PIL.Image.Image):
+                value = np.asarray(value)
+
+        # using global variable since `jaxlib.xla_extension.Device` is not serializable neither
+        # with `pickle` nor with `dill`, so we need to use a global variable instead
+        global DEVICE_MAPPING
+        if DEVICE_MAPPING is None:
+            DEVICE_MAPPING = self._map_devices_to_str()
+
+        with jax.default_device(DEVICE_MAPPING[self.device]):
+            # calling jnp.array on a np.ndarray does copy the data
+            # see https://github.com/google/jax/issues/4486
+            return jnp.array(value, **{**default_dtype, **self.jnp_array_kwargs})
+
+    def _recursive_tensorize(self, data_struct):
+        import jax
+
+        # support for torch, tf, jax etc.
+        if config.TORCH_AVAILABLE and "torch" in sys.modules:
+            import torch
+
+            if isinstance(data_struct, torch.Tensor):
+                return self._tensorize(data_struct.detach().cpu().numpy()[()])
+        if hasattr(data_struct, "__array__") and not isinstance(data_struct, jax.Array):
+            data_struct = data_struct.__array__()
+        # support for nested types like struct of list of struct
+        if isinstance(data_struct, np.ndarray):
+            if data_struct.dtype == object:  # jax arrays cannot be instantied from an array of objects
+                return self._consolidate([self.recursive_tensorize(substruct) for substruct in data_struct])
+        elif isinstance(data_struct, (list, tuple)):
+            return self._consolidate([self.recursive_tensorize(substruct) for substruct in data_struct])
+        return self._tensorize(data_struct)
+
+    def recursive_tensorize(self, data_struct: dict):
+        return map_nested(self._recursive_tensorize, data_struct, map_list=False)
+
+    def format_row(self, pa_table: pa.Table) -> Mapping:
+        row = self.numpy_arrow_extractor().extract_row(pa_table)
+        row = self.python_features_decoder.decode_row(row)
+        return self.recursive_tensorize(row)
+
+    def format_column(self, pa_table: pa.Table) -> "jax.Array":
+        column = self.numpy_arrow_extractor().extract_column(pa_table)
+        column = self.python_features_decoder.decode_column(column, pa_table.column_names[0])
+        column = self.recursive_tensorize(column)
+        column = self._consolidate(column)
+        return column
+
+    def format_batch(self, pa_table: pa.Table) -> Mapping:
+        batch = self.numpy_arrow_extractor().extract_batch(pa_table)
+        batch = self.python_features_decoder.decode_batch(batch)
+        batch = self.recursive_tensorize(batch)
+        for column_name in batch:
+            batch[column_name] = self._consolidate(batch[column_name])
+        return batch

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

@@ -0,0 +1,106 @@
+# Copyright 2020 The HuggingFace Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import sys
+from collections.abc import Mapping
+
+import numpy as np
+import pyarrow as pa
+
+from .. import config
+from ..utils.py_utils import map_nested
+from .formatting import TensorFormatter
+
+
+class NumpyFormatter(TensorFormatter[Mapping, np.ndarray, Mapping]):
+    def __init__(self, features=None, **np_array_kwargs):
+        super().__init__(features=features)
+        self.np_array_kwargs = np_array_kwargs
+
+    def _consolidate(self, column):
+        if isinstance(column, list):
+            if column and all(
+                isinstance(x, np.ndarray) and x.shape == column[0].shape and x.dtype == column[0].dtype for x in column
+            ):
+                return np.stack(column)
+            else:
+                # don't use np.array(column, dtype=object)
+                # since it fails in certain cases
+                # see https://stackoverflow.com/q/51005699
+                out = np.empty(len(column), dtype=object)
+                out[:] = column
+                return out
+        return column
+
+    def _tensorize(self, value):
+        if isinstance(value, (str, bytes, type(None))):
+            return value
+        elif isinstance(value, (np.character, np.ndarray)) and np.issubdtype(value.dtype, np.character):
+            return value
+        elif isinstance(value, np.number):
+            return value
+
+        default_dtype = {}
+
+        if isinstance(value, np.ndarray) and np.issubdtype(value.dtype, np.integer):
+            default_dtype = {"dtype": np.int64}
+        elif isinstance(value, np.ndarray) and np.issubdtype(value.dtype, np.floating):
+            default_dtype = {"dtype": np.float32}
+        elif config.PIL_AVAILABLE and "PIL" in sys.modules:
+            import PIL.Image
+
+            if isinstance(value, PIL.Image.Image):
+                return np.asarray(value, **self.np_array_kwargs)
+
+        return np.asarray(value, **{**default_dtype, **self.np_array_kwargs})
+
+    def _recursive_tensorize(self, data_struct):
+        # support for torch, tf, jax etc.
+        if config.TORCH_AVAILABLE and "torch" in sys.modules:
+            import torch
+
+            if isinstance(data_struct, torch.Tensor):
+                return self._tensorize(data_struct.detach().cpu().numpy()[()])
+        if hasattr(data_struct, "__array__") and not isinstance(data_struct, (np.ndarray, np.character, np.number)):
+            data_struct = data_struct.__array__()
+        # support for nested types like struct of list of struct
+        if isinstance(data_struct, np.ndarray):
+            if data_struct.dtype == object:
+                return self._consolidate([self.recursive_tensorize(substruct) for substruct in data_struct])
+        if isinstance(data_struct, (list, tuple)):
+            return self._consolidate([self.recursive_tensorize(substruct) for substruct in data_struct])
+        return self._tensorize(data_struct)
+
+    def recursive_tensorize(self, data_struct: dict):
+        return map_nested(self._recursive_tensorize, data_struct, map_list=False)
+
+    def format_row(self, pa_table: pa.Table) -> Mapping:
+        row = self.numpy_arrow_extractor().extract_row(pa_table)
+        row = self.python_features_decoder.decode_row(row)
+        return self.recursive_tensorize(row)
+
+    def format_column(self, pa_table: pa.Table) -> np.ndarray:
+        column = self.numpy_arrow_extractor().extract_column(pa_table)
+        column = self.python_features_decoder.decode_column(column, pa_table.column_names[0])
+        column = self.recursive_tensorize(column)
+        column = self._consolidate(column)
+        return column
+
+    def format_batch(self, pa_table: pa.Table) -> Mapping:
+        batch = self.numpy_arrow_extractor().extract_batch(pa_table)
+        batch = self.python_features_decoder.decode_batch(batch)
+        batch = self.recursive_tensorize(batch)
+        for column_name in batch:
+            batch[column_name] = self._consolidate(batch[column_name])
+        return batch

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

@@ -0,0 +1,122 @@
+# Copyright 2020 The HuggingFace Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import sys
+from collections.abc import Mapping
+from functools import partial
+from typing import TYPE_CHECKING, Optional
+
+import pyarrow as pa
+
+from .. import config
+from ..features import Features
+from ..features.features import decode_nested_example
+from ..utils.py_utils import no_op_if_value_is_null
+from .formatting import BaseArrowExtractor, TensorFormatter
+
+
+if TYPE_CHECKING:
+    import polars as pl
+
+
+class PolarsArrowExtractor(BaseArrowExtractor["pl.DataFrame", "pl.Series", "pl.DataFrame"]):
+    def extract_row(self, pa_table: pa.Table) -> "pl.DataFrame":
+        if config.POLARS_AVAILABLE:
+            if "polars" not in sys.modules:
+                import polars
+            else:
+                polars = sys.modules["polars"]
+
+            return polars.from_arrow(pa_table.slice(length=1))
+        else:
+            raise ValueError("Polars needs to be installed to be able to return Polars dataframes.")
+
+    def extract_column(self, pa_table: pa.Table) -> "pl.Series":
+        if config.POLARS_AVAILABLE:
+            if "polars" not in sys.modules:
+                import polars
+            else:
+                polars = sys.modules["polars"]
+
+            return polars.from_arrow(pa_table.select([0]))[pa_table.column_names[0]]
+        else:
+            raise ValueError("Polars needs to be installed to be able to return Polars dataframes.")
+
+    def extract_batch(self, pa_table: pa.Table) -> "pl.DataFrame":
+        if config.POLARS_AVAILABLE:
+            if "polars" not in sys.modules:
+                import polars
+            else:
+                polars = sys.modules["polars"]
+
+            return polars.from_arrow(pa_table)
+        else:
+            raise ValueError("Polars needs to be installed to be able to return Polars dataframes.")
+
+
+class PolarsFeaturesDecoder:
+    def __init__(self, features: Optional[Features]):
+        self.features = features
+        import polars as pl  # noqa: F401 - import pl at initialization
+
+    def decode_row(self, row: "pl.DataFrame") -> "pl.DataFrame":
+        decode = (
+            {
+                column_name: no_op_if_value_is_null(partial(decode_nested_example, feature))
+                for column_name, feature in self.features.items()
+                if self.features._column_requires_decoding[column_name]
+            }
+            if self.features
+            else {}
+        )
+        if decode:
+            row[list(decode.keys())] = row.map_rows(decode)
+        return row
+
+    def decode_column(self, column: "pl.Series", column_name: str) -> "pl.Series":
+        decode = (
+            no_op_if_value_is_null(partial(decode_nested_example, self.features[column_name]))
+            if self.features and column_name in self.features and self.features._column_requires_decoding[column_name]
+            else None
+        )
+        if decode:
+            column = column.map_elements(decode)
+        return column
+
+    def decode_batch(self, batch: "pl.DataFrame") -> "pl.DataFrame":
+        return self.decode_row(batch)
+
+
+class PolarsFormatter(TensorFormatter[Mapping, "pl.DataFrame", Mapping]):
+    def __init__(self, features=None, **np_array_kwargs):
+        super().__init__(features=features)
+        self.np_array_kwargs = np_array_kwargs
+        self.polars_arrow_extractor = PolarsArrowExtractor
+        self.polars_features_decoder = PolarsFeaturesDecoder(features)
+        import polars as pl  # noqa: F401 - import pl at initialization
+
+    def format_row(self, pa_table: pa.Table) -> "pl.DataFrame":
+        row = self.polars_arrow_extractor().extract_row(pa_table)
+        row = self.polars_features_decoder.decode_row(row)
+        return row
+
+    def format_column(self, pa_table: pa.Table) -> "pl.Series":
+        column = self.polars_arrow_extractor().extract_column(pa_table)
+        column = self.polars_features_decoder.decode_column(column, pa_table.column_names[0])
+        return column
+
+    def format_batch(self, pa_table: pa.Table) -> "pl.DataFrame":
+        row = self.polars_arrow_extractor().extract_batch(pa_table)
+        row = self.polars_features_decoder.decode_batch(row)
+        return row

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

@@ -0,0 +1,115 @@
+# Copyright 2020 The HuggingFace Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Lint as: python3
+import sys
+from collections.abc import Mapping
+from typing import TYPE_CHECKING
+
+import numpy as np
+import pyarrow as pa
+
+from .. import config
+from ..utils.py_utils import map_nested
+from .formatting import TensorFormatter
+
+
+if TYPE_CHECKING:
+    import tensorflow as tf
+
+
+class TFFormatter(TensorFormatter[Mapping, "tf.Tensor", Mapping]):
+    def __init__(self, features=None, **tf_tensor_kwargs):
+        super().__init__(features=features)
+        self.tf_tensor_kwargs = tf_tensor_kwargs
+        import tensorflow as tf  # noqa: F401 - import tf at initialization
+
+    def _consolidate(self, column):
+        import tensorflow as tf
+
+        if isinstance(column, list) and column:
+            if all(
+                isinstance(x, tf.Tensor) and x.shape == column[0].shape and x.dtype == column[0].dtype for x in column
+            ):
+                return tf.stack(column)
+            elif all(
+                isinstance(x, (tf.Tensor, tf.RaggedTensor)) and x.ndim == 1 and x.dtype == column[0].dtype
+                for x in column
+            ):
+                # only rag 1-D tensors, otherwise some dimensions become ragged even though they were consolidated
+                return tf.ragged.stack(column)
+
+        return column
+
+    def _tensorize(self, value):
+        import tensorflow as tf
+
+        if value is None:
+            return value
+
+        default_dtype = {}
+
+        if isinstance(value, (np.number, np.ndarray)) and np.issubdtype(value.dtype, np.integer):
+            default_dtype = {"dtype": tf.int64}
+        elif isinstance(value, (np.number, np.ndarray)) and np.issubdtype(value.dtype, np.floating):
+            default_dtype = {"dtype": tf.float32}
+        elif config.PIL_AVAILABLE and "PIL" in sys.modules:
+            import PIL.Image
+
+            if isinstance(value, PIL.Image.Image):
+                value = np.asarray(value)
+
+        return tf.convert_to_tensor(value, **{**default_dtype, **self.tf_tensor_kwargs})
+
+    def _recursive_tensorize(self, data_struct):
+        import tensorflow as tf
+
+        # support for torch, tf, jax etc.
+        if config.TORCH_AVAILABLE and "torch" in sys.modules:
+            import torch
+
+            if isinstance(data_struct, torch.Tensor):
+                return self._tensorize(data_struct.detach().cpu().numpy()[()])
+        if hasattr(data_struct, "__array__") and not isinstance(data_struct, tf.Tensor):
+            data_struct = data_struct.__array__()
+        # support for nested types like struct of list of struct
+        if isinstance(data_struct, np.ndarray):
+            if data_struct.dtype == object:  # tf tensors cannot be instantied from an array of objects
+                return self._consolidate([self.recursive_tensorize(substruct) for substruct in data_struct])
+        elif isinstance(data_struct, (list, tuple)):
+            return self._consolidate([self.recursive_tensorize(substruct) for substruct in data_struct])
+        return self._tensorize(data_struct)
+
+    def recursive_tensorize(self, data_struct: dict):
+        return map_nested(self._recursive_tensorize, data_struct, map_list=False)
+
+    def format_row(self, pa_table: pa.Table) -> Mapping:
+        row = self.numpy_arrow_extractor().extract_row(pa_table)
+        row = self.python_features_decoder.decode_row(row)
+        return self.recursive_tensorize(row)
+
+    def format_column(self, pa_table: pa.Table) -> "tf.Tensor":
+        column = self.numpy_arrow_extractor().extract_column(pa_table)
+        column = self.python_features_decoder.decode_column(column, pa_table.column_names[0])
+        column = self.recursive_tensorize(column)
+        column = self._consolidate(column)
+        return column
+
+    def format_batch(self, pa_table: pa.Table) -> Mapping:
+        batch = self.numpy_arrow_extractor().extract_batch(pa_table)
+        batch = self.python_features_decoder.decode_batch(batch)
+        batch = self.recursive_tensorize(batch)
+        for column_name in batch:
+            batch[column_name] = self._consolidate(batch[column_name])
+        return batch

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

@@ -0,0 +1,115 @@
+# Copyright 2020 The HuggingFace Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Lint as: python3
+import sys
+from collections.abc import Mapping
+from typing import TYPE_CHECKING
+
+import numpy as np
+import pyarrow as pa
+
+from .. import config
+from ..utils.py_utils import map_nested
+from .formatting import TensorFormatter
+
+
+if TYPE_CHECKING:
+    import torch
+
+
+class TorchFormatter(TensorFormatter[Mapping, "torch.Tensor", Mapping]):
+    def __init__(self, features=None, **torch_tensor_kwargs):
+        super().__init__(features=features)
+        self.torch_tensor_kwargs = torch_tensor_kwargs
+        import torch  # noqa import torch at initialization
+
+    def _consolidate(self, column):
+        import torch
+
+        if isinstance(column, list) and column:
+            if all(
+                isinstance(x, torch.Tensor) and x.shape == column[0].shape and x.dtype == column[0].dtype
+                for x in column
+            ):
+                return torch.stack(column)
+        return column
+
+    def _tensorize(self, value):
+        import torch
+
+        if isinstance(value, (str, bytes, type(None))):
+            return value
+        elif isinstance(value, (np.character, np.ndarray)) and np.issubdtype(value.dtype, np.character):
+            return value.tolist()
+
+        default_dtype = {}
+
+        if isinstance(value, (np.number, np.ndarray)) and np.issubdtype(value.dtype, np.integer):
+            default_dtype = {"dtype": torch.int64}
+
+            # Convert dtype to np.int64 if it's either np.uint16 or np.uint32 to ensure compatibility.
+            # np.uint64 is excluded from this conversion as there is no compatible PyTorch dtype that can handle it without loss.
+            if value.dtype in [np.uint16, np.uint32]:
+                value = value.astype(np.int64)
+
+        elif isinstance(value, (np.number, np.ndarray)) and np.issubdtype(value.dtype, np.floating):
+            default_dtype = {"dtype": torch.float32}
+        elif config.PIL_AVAILABLE and "PIL" in sys.modules:
+            import PIL.Image
+
+            if isinstance(value, PIL.Image.Image):
+                value = np.asarray(value)
+                if value.ndim == 2:
+                    value = value[:, :, np.newaxis]
+
+                value = value.transpose((2, 0, 1))
+        return torch.tensor(value, **{**default_dtype, **self.torch_tensor_kwargs})
+
+    def _recursive_tensorize(self, data_struct):
+        import torch
+
+        # support for torch, tf, jax etc.
+        if hasattr(data_struct, "__array__") and not isinstance(data_struct, torch.Tensor):
+            data_struct = data_struct.__array__()
+        # support for nested types like struct of list of struct
+        if isinstance(data_struct, np.ndarray):
+            if data_struct.dtype == object:  # torch tensors cannot be instantied from an array of objects
+                return self._consolidate([self.recursive_tensorize(substruct) for substruct in data_struct])
+        elif isinstance(data_struct, (list, tuple)):
+            return self._consolidate([self.recursive_tensorize(substruct) for substruct in data_struct])
+        return self._tensorize(data_struct)
+
+    def recursive_tensorize(self, data_struct: dict):
+        return map_nested(self._recursive_tensorize, data_struct, map_list=False)
+
+    def format_row(self, pa_table: pa.Table) -> Mapping:
+        row = self.numpy_arrow_extractor().extract_row(pa_table)
+        row = self.python_features_decoder.decode_row(row)
+        return self.recursive_tensorize(row)
+
+    def format_column(self, pa_table: pa.Table) -> "torch.Tensor":
+        column = self.numpy_arrow_extractor().extract_column(pa_table)
+        column = self.python_features_decoder.decode_column(column, pa_table.column_names[0])
+        column = self.recursive_tensorize(column)
+        column = self._consolidate(column)
+        return column
+
+    def format_batch(self, pa_table: pa.Table) -> Mapping:
+        batch = self.numpy_arrow_extractor().extract_batch(pa_table)
+        batch = self.python_features_decoder.decode_batch(batch)
+        batch = self.recursive_tensorize(batch)
+        for column_name in batch:
+            batch[column_name] = self._consolidate(batch[column_name])
+        return batch

llmeval-env/lib/python3.10/site-packages/multidict-6.0.5.dist-info/INSTALLER

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

llmeval-env/lib/python3.10/site-packages/multidict-6.0.5.dist-info/LICENSE

@@ -0,0 +1,13 @@
+   Copyright 2016 Andrew Svetlov and aio-libs contributors
+
+   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.

llmeval-env/lib/python3.10/site-packages/multidict-6.0.5.dist-info/METADATA

@@ -0,0 +1,132 @@
+Metadata-Version: 2.1
+Name: multidict
+Version: 6.0.5
+Summary: multidict implementation
+Home-page: https://github.com/aio-libs/multidict
+Author: Andrew Svetlov
+Author-email: [email protected]
+License: Apache 2
+Project-URL: Chat: Gitter, https://gitter.im/aio-libs/Lobby
+Project-URL: CI: GitHub, https://github.com/aio-libs/multidict/actions
+Project-URL: Coverage: codecov, https://codecov.io/github/aio-libs/multidict
+Project-URL: Docs: RTD, https://multidict.aio-libs.org
+Project-URL: GitHub: issues, https://github.com/aio-libs/multidict/issues
+Project-URL: GitHub: repo, https://github.com/aio-libs/multidict
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+
+=========
+multidict
+=========
+
+.. image:: https://github.com/aio-libs/multidict/workflows/CI/badge.svg
+   :target: https://github.com/aio-libs/multidict/actions?query=workflow%3ACI
+   :alt: GitHub status for master branch
+
+.. image:: https://codecov.io/gh/aio-libs/multidict/branch/master/graph/badge.svg
+   :target: https://codecov.io/gh/aio-libs/multidict
+   :alt: Coverage metrics
+
+.. image:: https://img.shields.io/pypi/v/multidict.svg
+   :target: https://pypi.org/project/multidict
+   :alt: PyPI
+
+.. image:: https://readthedocs.org/projects/multidict/badge/?version=latest
+   :target: http://multidict.aio-libs.org/en/latest/?badge=latest
+   :alt: Documentation
+
+.. image:: https://img.shields.io/pypi/pyversions/multidict.svg
+   :target: https://pypi.org/project/multidict
+   :alt: Python versions
+
+.. image:: https://badges.gitter.im/Join%20Chat.svg
+   :target: https://gitter.im/aio-libs/Lobby
+   :alt: Chat on Gitter
+
+Multidict is dict-like collection of *key-value pairs* where key
+might occur more than once in the container.
+
+Introduction
+------------
+
+*HTTP Headers* and *URL query string* require specific data structure:
+*multidict*. It behaves mostly like a regular ``dict`` but it may have
+several *values* for the same *key* and *preserves insertion ordering*.
+
+The *key* is ``str`` (or ``istr`` for case-insensitive dictionaries).
+
+``multidict`` has four multidict classes:
+``MultiDict``, ``MultiDictProxy``, ``CIMultiDict``
+and ``CIMultiDictProxy``.
+
+Immutable proxies (``MultiDictProxy`` and
+``CIMultiDictProxy``) provide a dynamic view for the
+proxied multidict, the view reflects underlying collection changes. They
+implement the ``collections.abc.Mapping`` interface.
+
+Regular mutable (``MultiDict`` and ``CIMultiDict``) classes
+implement ``collections.abc.MutableMapping`` and allows them to change
+their own content.
+
+
+*Case insensitive* (``CIMultiDict`` and
+``CIMultiDictProxy``) assume the *keys* are case
+insensitive, e.g.::
+
+   >>> dct = CIMultiDict(key='val')
+   >>> 'Key' in dct
+   True
+   >>> dct['Key']
+   'val'
+
+*Keys* should be ``str`` or ``istr`` instances.
+
+The library has optional C Extensions for speed.
+
+
+License
+-------
+
+Apache 2
+
+Library Installation
+--------------------
+
+.. code-block:: bash
+
+   $ pip install multidict
+
+The library is Python 3 only!
+
+PyPI contains binary wheels for Linux, Windows and MacOS.  If you want to install
+``multidict`` on another operating system (or *Alpine Linux* inside a Docker) the
+tarball will be used to compile the library from source.  It requires a C compiler and
+Python headers to be installed.
+
+To skip the compilation, please use the `MULTIDICT_NO_EXTENSIONS` environment variable,
+e.g.:
+
+.. code-block:: bash
+
+   $ MULTIDICT_NO_EXTENSIONS=1 pip install multidict
+
+Please note, the pure Python (uncompiled) version is about 20-50 times slower depending on
+the usage scenario!!!
+
+
+
+Changelog
+---------
+See `RTD page <http://multidict.aio-libs.org/en/latest/changes>`_.

llmeval-env/lib/python3.10/site-packages/multidict-6.0.5.dist-info/RECORD

@@ -0,0 +1,19 @@
+multidict-6.0.5.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+multidict-6.0.5.dist-info/LICENSE,sha256=k9Ealo4vDzY3PECBH_bSDhc_WMPKtYhM1mF7v9eVSSo,611
+multidict-6.0.5.dist-info/METADATA,sha256=fGbYCQYEMcDtxEz2H6GLf1np9JtMhNTaLVzgAhsQYzU,4214
+multidict-6.0.5.dist-info/RECORD,,
+multidict-6.0.5.dist-info/WHEEL,sha256=1FEjxEYgybphwh9S0FO9IcZ0B-NIeM2ko8OzhFZeOeQ,152
+multidict-6.0.5.dist-info/top_level.txt,sha256=-euDElkk5_qkmfIJ7WiqCab02ZlSFZWynejKg59qZQQ,10
+multidict/__init__.py,sha256=psbRrP64CD22Wjoc_OoqG9QlkRGcaZfOFCoPmoUiMig,928
+multidict/__init__.pyi,sha256=SbgC2ew1NvNXWlRKs9o0KhW4moozgMqgQ0OA4Re5JQQ,4840
+multidict/__pycache__/__init__.cpython-310.pyc,,
+multidict/__pycache__/_abc.cpython-310.pyc,,
+multidict/__pycache__/_compat.cpython-310.pyc,,
+multidict/__pycache__/_multidict_base.cpython-310.pyc,,
+multidict/__pycache__/_multidict_py.cpython-310.pyc,,
+multidict/_abc.py,sha256=Zvnrn4SBkrv4QTD7-ZzqNcoxw0f8KStLMPzGvBuGT2w,1190
+multidict/_compat.py,sha256=tjUGdP9ooiH6c2KJrvUbPRwcvjWerKlKU6InIviwh7w,316
+multidict/_multidict.cpython-310-x86_64-linux-gnu.so,sha256=BmNKiShRM0HlwDp_fjuenfzDjBlo6C0BEfpi55TRp-k,394656
+multidict/_multidict_base.py,sha256=XugkE78fXBmtzDdg2Yi9TrEhDexmL-6qJbFIG0viLMg,3791
+multidict/_multidict_py.py,sha256=57h4sYrRIu7EjMX4YpHVIZVrV9-q1KCW3F6rao10D3U,15050
+multidict/py.typed,sha256=e9bmbH3UFxsabQrnNFPG9qxIXztwbcM6IKDYnvZwprY,15

llmeval-env/lib/python3.10/site-packages/multidict-6.0.5.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.42.0)
+Root-Is-Purelib: false
+Tag: cp310-cp310-manylinux_2_17_x86_64
+Tag: cp310-cp310-manylinux2014_x86_64
+

llmeval-env/lib/python3.10/site-packages/multiprocess-0.70.16.dist-info/COPYING

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

llmeval-env/lib/python3.10/site-packages/multiprocess-0.70.16.dist-info/INSTALLER

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

llmeval-env/lib/python3.10/site-packages/multiprocess-0.70.16.dist-info/LICENSE

@@ -0,0 +1,38 @@
+Copyright (c) 2008-2016 California Institute of Technology.
+Copyright (c) 2016-2024 The Uncertainty Quantification Foundation.
+All rights reserved.
+
+This software forks the python package "multiprocessing". Licence and
+copyright information for multiprocessing can be found in "COPYING".
+
+This software is available subject to the conditions and terms laid
+out below. By downloading and using this software you are agreeing
+to the following conditions.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+    - Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    - Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+    - Neither the names of the copyright holders nor the names of any of
+      the contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

llmeval-env/lib/python3.10/site-packages/multiprocess-0.70.16.dist-info/METADATA

@@ -0,0 +1,203 @@
+Metadata-Version: 2.1
+Name: multiprocess
+Version: 0.70.16
+Summary: better multiprocessing and multithreading in Python
+Home-page: https://github.com/uqfoundation/multiprocess
+Download-URL: https://pypi.org/project/multiprocess/#files
+Author: Mike McKerns
+Author-email: [email protected]
+Maintainer: Mike McKerns
+Maintainer-email: [email protected]
+License: BSD-3-Clause
+Project-URL: Documentation, http://multiprocess.rtfd.io
+Project-URL: Source Code, https://github.com/uqfoundation/multiprocess
+Project-URL: Bug Tracker, https://github.com/uqfoundation/multiprocess/issues
+Platform: Linux
+Platform: Windows
+Platform: Mac
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development
+Requires-Python: >=3.8
+License-File: LICENSE
+License-File: COPYING
+Requires-Dist: dill (>=0.3.8)
+
+-----------------------------------------------------------------
+multiprocess: better multiprocessing and multithreading in Python
+-----------------------------------------------------------------
+
+About Multiprocess
+==================
+
+``multiprocess`` is a fork of ``multiprocessing``. ``multiprocess`` extends ``multiprocessing`` to provide enhanced serialization, using `dill`. ``multiprocess`` leverages ``multiprocessing`` to support the spawning of processes using the API of the Python standard library's ``threading`` module. ``multiprocessing`` has been distributed as part of the standard library since Python 2.6.
+
+``multiprocess`` is part of ``pathos``,  a Python framework for heterogeneous computing.
+``multiprocess`` is in active development, so any user feedback, bug reports, comments,
+or suggestions are highly appreciated.  A list of issues is located at https://github.com/uqfoundation/multiprocess/issues, with a legacy list maintained at https://uqfoundation.github.io/project/pathos/query.
+
+
+Major Features
+==============
+
+``multiprocess`` enables:
+
+    - objects to be transferred between processes using pipes or multi-producer/multi-consumer queues
+    - objects to be shared between processes using a server process or (for simple data) shared memory
+
+``multiprocess`` provides:
+
+    - equivalents of all the synchronization primitives in ``threading``
+    - a ``Pool`` class to facilitate submitting tasks to worker processes
+    - enhanced serialization, using ``dill``
+
+
+Current Release
+===============
+
+The latest released version of ``multiprocess`` is available from:
+
+    https://pypi.org/project/multiprocess
+
+``multiprocess`` is distributed under a 3-clause BSD license, and is a fork of ``multiprocessing``.
+
+
+Development Version
+===================
+
+You can get the latest development version with all the shiny new features at:
+
+    https://github.com/uqfoundation
+
+If you have a new contribution, please submit a pull request.
+
+
+Installation
+============
+
+``multiprocess`` can be installed with ``pip``::
+
+    $ pip install multiprocess
+
+For Python 2, a C compiler is required to build the included extension module from source. Python 3 and binary installs do not require a C compiler.
+
+
+Requirements
+============
+
+``multiprocess`` requires:
+
+    - ``python`` (or ``pypy``), **>=3.8**
+    - ``setuptools``, **>=42**
+    - ``dill``, **>=0.3.8**
+
+
+Basic Usage
+===========
+
+The ``multiprocess.Process`` class follows the API of ``threading.Thread``.
+For example ::
+
+    from multiprocess import Process, Queue
+
+    def f(q):
+        q.put('hello world')
+
+    if __name__ == '__main__':
+        q = Queue()
+        p = Process(target=f, args=[q])
+        p.start()
+        print (q.get())
+        p.join()
+
+Synchronization primitives like locks, semaphores and conditions are
+available, for example ::
+
+    >>> from multiprocess import Condition
+    >>> c = Condition()
+    >>> print (c)
+    <Condition(<RLock(None, 0)>), 0>
+    >>> c.acquire()
+    True
+    >>> print (c)
+    <Condition(<RLock(MainProcess, 1)>), 0>
+
+One can also use a manager to create shared objects either in shared
+memory or in a server process, for example ::
+
+    >>> from multiprocess import Manager
+    >>> manager = Manager()
+    >>> l = manager.list(range(10))
+    >>> l.reverse()
+    >>> print (l)
+    [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
+    >>> print (repr(l))
+    <Proxy[list] object at 0x00E1B3B0>
+
+Tasks can be offloaded to a pool of worker processes in various ways,
+for example ::
+
+    >>> from multiprocess import Pool
+    >>> def f(x): return x*x
+    ...
+    >>> p = Pool(4)
+    >>> result = p.map_async(f, range(10))
+    >>> print (result.get(timeout=1))
+    [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
+
+When ``dill`` is installed, serialization is extended to most objects,
+for example ::
+
+    >>> from multiprocess import Pool
+    >>> p = Pool(4)
+    >>> print (p.map(lambda x: (lambda y:y**2)(x) + x, xrange(10)))
+    [0, 2, 6, 12, 20, 30, 42, 56, 72, 90]
+
+
+More Information
+================
+
+Probably the best way to get started is to look at the documentation at
+http://multiprocess.rtfd.io. Also see ``multiprocess.tests`` for scripts that
+demonstrate how ``multiprocess`` can be used to leverge multiple processes
+to execute Python in parallel. You can run the test suite with
+``python -m multiprocess.tests``. As ``multiprocess`` conforms to the
+``multiprocessing`` interface, the examples and documentation found at
+http://docs.python.org/library/multiprocessing.html also apply to
+``multiprocess`` if one will ``import multiprocessing as multiprocess``.
+See https://github.com/uqfoundation/multiprocess/tree/master/py3.12/examples
+for a set of examples that demonstrate some basic use cases and benchmarking
+for running Python code in parallel. Please feel free to submit a ticket on
+github, or ask a question on stackoverflow (**@Mike McKerns**). If you would
+like to share how you use ``multiprocess`` in your work, please send an email
+(to **mmckerns at uqfoundation dot org**).
+
+
+Citation
+========
+
+If you use ``multiprocess`` to do research that leads to publication, we ask that you
+acknowledge use of ``multiprocess`` by citing the following in your publication::
+
+    M.M. McKerns, L. Strand, T. Sullivan, A. Fang, M.A.G. Aivazis,
+    "Building a framework for predictive science", Proceedings of
+    the 10th Python in Science Conference, 2011;
+    http://arxiv.org/pdf/1202.1056
+
+    Michael McKerns and Michael Aivazis,
+    "pathos: a framework for heterogeneous computing", 2010- ;
+    https://uqfoundation.github.io/project/pathos
+
+Please see https://uqfoundation.github.io/project/pathos or
+http://arxiv.org/pdf/1202.1056 for further information.

llmeval-env/lib/python3.10/site-packages/multiprocess-0.70.16.dist-info/RECORD

@@ -0,0 +1,73 @@
+_multiprocess/__init__.py,sha256=zX5_h36TGSL0brHRtBvCL5E59ccW7yjL79i-Y399ODM,321
+_multiprocess/__pycache__/__init__.cpython-310.pyc,,
+multiprocess-0.70.16.dist-info/COPYING,sha256=n3_yfLkw0sMgLuB-PS1hRvTeZ20GmjPaMWbJjNuoOpU,1493
+multiprocess-0.70.16.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+multiprocess-0.70.16.dist-info/LICENSE,sha256=6XUJedJKg2dhI98BD3PMtVtZvRFT-oGczkOr5B4tEEA,1930
+multiprocess-0.70.16.dist-info/METADATA,sha256=Sv2eH2CjjyjVYaryTKqHkbJTlxlVA-SbmziCgkBJeQ0,7151
+multiprocess-0.70.16.dist-info/RECORD,,
+multiprocess-0.70.16.dist-info/WHEEL,sha256=KxatxaZA14OswIJTdImHhiM2tdZgU-xLZEzs-sYveVc,94
+multiprocess-0.70.16.dist-info/top_level.txt,sha256=qtJc8GNdvi6suNpISX0Myln9AXJBYrNuas1MCqRPPqg,27
+multiprocess/__info__.py,sha256=84TUBn1oJMNpbVvXKs0lKyfLYaZvRr-ZVh1zHM9VeCY,7997
+multiprocess/__init__.py,sha256=XWUBDGorUkDW04h64xe51pUV9N5gzvSDj3tNT2ekifw,1856
+multiprocess/__pycache__/__info__.cpython-310.pyc,,
+multiprocess/__pycache__/__init__.cpython-310.pyc,,
+multiprocess/__pycache__/connection.cpython-310.pyc,,
+multiprocess/__pycache__/context.cpython-310.pyc,,
+multiprocess/__pycache__/forkserver.cpython-310.pyc,,
+multiprocess/__pycache__/heap.cpython-310.pyc,,
+multiprocess/__pycache__/managers.cpython-310.pyc,,
+multiprocess/__pycache__/pool.cpython-310.pyc,,
+multiprocess/__pycache__/popen_fork.cpython-310.pyc,,
+multiprocess/__pycache__/popen_forkserver.cpython-310.pyc,,
+multiprocess/__pycache__/popen_spawn_posix.cpython-310.pyc,,
+multiprocess/__pycache__/popen_spawn_win32.cpython-310.pyc,,
+multiprocess/__pycache__/process.cpython-310.pyc,,
+multiprocess/__pycache__/queues.cpython-310.pyc,,
+multiprocess/__pycache__/reduction.cpython-310.pyc,,
+multiprocess/__pycache__/resource_sharer.cpython-310.pyc,,
+multiprocess/__pycache__/resource_tracker.cpython-310.pyc,,
+multiprocess/__pycache__/shared_memory.cpython-310.pyc,,
+multiprocess/__pycache__/sharedctypes.cpython-310.pyc,,
+multiprocess/__pycache__/spawn.cpython-310.pyc,,
+multiprocess/__pycache__/synchronize.cpython-310.pyc,,
+multiprocess/__pycache__/util.cpython-310.pyc,,
+multiprocess/connection.py,sha256=TO9BbLVlLVjTjr0fP7lIumBgiLwaFVnpqMBgFG6iL9s,31843
+multiprocess/context.py,sha256=2fYvgfnu3B8wj8UyNndHUHgeuVDoVxlkFFKryycstaU,11610
+multiprocess/dummy/__init__.py,sha256=kSekDqD_NCy0FDg7XnxZSgW-Ldg1_iRr07sNwDajKpA,3061
+multiprocess/dummy/__pycache__/__init__.cpython-310.pyc,,
+multiprocess/dummy/__pycache__/connection.cpython-310.pyc,,
+multiprocess/dummy/connection.py,sha256=1j3Rl5_enBM-_kMO6HDmum3kPAoFE4Zs485HV5H-V6s,1598
+multiprocess/forkserver.py,sha256=hiltKfLImDYJyAcezNAgMDaQznB2LtYWgwre0QroLRg,12138
+multiprocess/heap.py,sha256=9rt5u5m5rkhJNfDWiCLpYDoWIt0LbElmx52yMqk7phQ,11626
+multiprocess/managers.py,sha256=Y5m_aCdLE4mSCuyVrwMWg5Nh9f4OdSHDlSajyOgyGao,47562
+multiprocess/pool.py,sha256=FTmtfoqkuN8Dd48f5TgdkokoxYN75xcnR78Hw-bLSng,32759
+multiprocess/popen_fork.py,sha256=Nvq5vVId24UfkOQxXhxZbcXuo8d6YMc409yRXAamTd0,2374
+multiprocess/popen_forkserver.py,sha256=SrEbV8Wv0Uu_UegkaW-cayXRdjTGXr560Yyy90pj-yE,2227
+multiprocess/popen_spawn_posix.py,sha256=l7XSWqR5UWiUSJh35qeSElLuNfUeEYwvH5HzKRnnyqg,2029
+multiprocess/popen_spawn_win32.py,sha256=A9uvlPmhO8JBzNcEU_Gmix2Q_qYJW1NXZgXPwtN5Ao0,4011
+multiprocess/process.py,sha256=GIIo2NiBsX1r_m0J1TcnbdeSulGLWHElRCuYRkkdgQ4,12083
+multiprocess/queues.py,sha256=sgXCXnIOVrPScqI3lwRD9t3IshqIBMEksLtouPH9Nzc,12139
+multiprocess/reduction.py,sha256=NQQ6KbDhmuAyaDeWaIarTZQokGPhcFda1poNnPm5uNc,9637
+multiprocess/resource_sharer.py,sha256=nEApLhMQqd8KunfaNKl3n8vdeiCGPxKrSL1Ja0nNAEk,5132
+multiprocess/resource_tracker.py,sha256=_D2iX4IWRe3dOwLoLjfCnXNbDAM4pRzA8qEMTcRfutw,9056
+multiprocess/shared_memory.py,sha256=UTAecHECIOHElP9Tg6yURCo4pKZiLy65TkASjEXeGus,18458
+multiprocess/sharedctypes.py,sha256=d-9SKRJHRlJJC331IxEoWOUXIeY9zxCbhWejXOmzGw0,6306
+multiprocess/spawn.py,sha256=cgtV66HhV_yIVzvdblc8bVdSpem16Ks0BOFu_bV5PDQ,9293
+multiprocess/synchronize.py,sha256=6q1ijwWyWLWLO8uUtaYT9MKepAYKfdzWPSEZGyJFP4s,11829
+multiprocess/tests/__init__.py,sha256=k00IjwhAUV_O1bp81895vN1gLnFzBM3iM-QTn5VrQnU,199087
+multiprocess/tests/__main__.py,sha256=RauIRQrO0HwRq_clLqbBk4gwo5Xw3-ASLuC029XaHeA,912
+multiprocess/tests/__pycache__/__init__.cpython-310.pyc,,
+multiprocess/tests/__pycache__/__main__.cpython-310.pyc,,
+multiprocess/tests/__pycache__/mp_fork_bomb.cpython-310.pyc,,
+multiprocess/tests/__pycache__/mp_preload.cpython-310.pyc,,
+multiprocess/tests/__pycache__/test_multiprocessing_fork.cpython-310.pyc,,
+multiprocess/tests/__pycache__/test_multiprocessing_forkserver.cpython-310.pyc,,
+multiprocess/tests/__pycache__/test_multiprocessing_main_handling.cpython-310.pyc,,
+multiprocess/tests/__pycache__/test_multiprocessing_spawn.cpython-310.pyc,,
+multiprocess/tests/mp_fork_bomb.py,sha256=6ADOEzh1aXHZ21aOGoBPhKcgB5sj15G9tQVgSc6GrlY,448
+multiprocess/tests/mp_preload.py,sha256=1-WvLFMaPoH-vZbpUaJvvZHFxTpA9tgmct2vblQy99M,365
+multiprocess/tests/test_multiprocessing_fork.py,sha256=ue1SQLJFxm1oc_3F2gR_WRtt39jhaj0l_Ht6Y1MBmFo,476
+multiprocess/tests/test_multiprocessing_forkserver.py,sha256=VFlUuZI60gyRbNxfHWDlgmy3zm-dPTldLWuKQZ8KObs,391
+multiprocess/tests/test_multiprocessing_main_handling.py,sha256=mtmN0K-spqZCcZVNLf_HrhP186-knpY6eaoFonL1U4U,12018
+multiprocess/tests/test_multiprocessing_spawn.py,sha256=2UAisJX58GZCbYuDFay_x97R9akhzzjIA4VuUUzITOY,276
+multiprocess/util.py,sha256=OPI3CZ34BNwwwa7AqW-eGhnuSUsu-ozy2NRU8BYKuwg,14012

llmeval-env/lib/python3.10/site-packages/multiprocess-0.70.16.dist-info/WHEEL

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

llmeval-env/lib/python3.10/site-packages/multiprocess-0.70.16.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+_multiprocess
+multiprocess

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

@@ -0,0 +1,133 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+from dataproperty import LineBreakHandling
+
+from .__version__ import __author__, __copyright__, __email__, __license__, __version__
+from ._factory import TableWriterFactory
+from ._function import dumps_tabledata
+from ._logger import set_logger
+from ._table_format import FormatAttr, TableFormat
+from .error import (
+    EmptyTableDataError,
+    EmptyTableNameError,
+    EmptyValueError,
+    NotSupportedError,
+    WriterNotFoundError,
+)
+from .style import Align, Format
+from .typehint import (
+    Bool,
+    DateTime,
+    Dictionary,
+    Infinity,
+    Integer,
+    IpAddress,
+    List,
+    Nan,
+    NoneType,
+    NullString,
+    RealNumber,
+    String,
+)
+from .writer import (
+    AbstractTableWriter,
+    AsciiDocTableWriter,
+    BoldUnicodeTableWriter,
+    BorderlessTableWriter,
+    CssTableWriter,
+    CsvTableWriter,
+    ElasticsearchWriter,
+    ExcelXlsTableWriter,
+    ExcelXlsxTableWriter,
+    HtmlTableWriter,
+    JavaScriptTableWriter,
+    JsonLinesTableWriter,
+    JsonTableWriter,
+    LatexMatrixWriter,
+    LatexTableWriter,
+    LtsvTableWriter,
+    MarkdownTableWriter,
+    MediaWikiTableWriter,
+    NullTableWriter,
+    NumpyTableWriter,
+    PandasDataFramePickleWriter,
+    PandasDataFrameWriter,
+    PythonCodeTableWriter,
+    RstCsvTableWriter,
+    RstGridTableWriter,
+    RstSimpleTableWriter,
+    SpaceAlignedTableWriter,
+    SqliteTableWriter,
+    TomlTableWriter,
+    TsvTableWriter,
+    UnicodeTableWriter,
+    YamlTableWriter,
+)
+
+
+__all__ = (
+    "__author__",
+    "__copyright__",
+    "__email__",
+    "__license__",
+    "__version__",
+    "LineBreakHandling",
+    "TableWriterFactory",
+    "dumps_tabledata",
+    "set_logger",
+    "FormatAttr",
+    "TableFormat",
+    "Align",
+    "Format",
+    "Bool",
+    "DateTime",
+    "Dictionary",
+    "Infinity",
+    "Integer",
+    "IpAddress",
+    "List",
+    "Nan",
+    "NoneType",
+    "NullString",
+    "RealNumber",
+    "String",
+    "EmptyTableDataError",
+    "EmptyTableNameError",
+    "EmptyValueError",
+    "NotSupportedError",
+    "WriterNotFoundError",
+    "AbstractTableWriter",
+    "AsciiDocTableWriter",
+    "BoldUnicodeTableWriter",
+    "BorderlessTableWriter",
+    "CssTableWriter",
+    "CsvTableWriter",
+    "ElasticsearchWriter",
+    "ExcelXlsTableWriter",
+    "ExcelXlsxTableWriter",
+    "HtmlTableWriter",
+    "JavaScriptTableWriter",
+    "JsonLinesTableWriter",
+    "JsonTableWriter",
+    "LatexMatrixWriter",
+    "LatexTableWriter",
+    "LtsvTableWriter",
+    "MarkdownTableWriter",
+    "MediaWikiTableWriter",
+    "NullTableWriter",
+    "NumpyTableWriter",
+    "PandasDataFramePickleWriter",
+    "PandasDataFrameWriter",
+    "PythonCodeTableWriter",
+    "RstCsvTableWriter",
+    "RstGridTableWriter",
+    "RstSimpleTableWriter",
+    "SpaceAlignedTableWriter",
+    "SqliteTableWriter",
+    "TomlTableWriter",
+    "TsvTableWriter",
+    "UnicodeTableWriter",
+    "YamlTableWriter",
+)

llmeval-env/lib/python3.10/site-packages/pytablewriter/__version__.py

@@ -0,0 +1,6 @@
+__author__ = "Tsuyoshi Hombashi"
+__copyright__ = f"Copyright 2016, {__author__}"
+__license__ = "MIT License"
+__version__ = "1.2.0"
+__maintainer__ = __author__
+__email__ = "[email protected]"

llmeval-env/lib/python3.10/site-packages/pytablewriter/_converter.py

@@ -0,0 +1,11 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+import re
+
+
+def strip_quote(text: str, value: str) -> str:
+    re_replace = re.compile(f"[\"']{value:s}[\"']", re.MULTILINE)
+
+    return re_replace.sub(value, text)

llmeval-env/lib/python3.10/site-packages/pytablewriter/_factory.py

@@ -0,0 +1,274 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+import os
+from itertools import chain
+from typing import Any, List
+
+import typepy
+
+from ._logger import logger
+from ._table_format import FormatAttr, TableFormat
+from .error import WriterNotFoundError
+from .writer import AbstractTableWriter
+
+
+class TableWriterFactory:
+    """
+    A factory class of table writer classes.
+    """
+
+    @classmethod
+    def create_from_file_extension(cls, file_extension: str, **kwargs: Any) -> AbstractTableWriter:
+        """
+        Create a table writer class instance from a file extension.
+        Supported file extensions are as follows:
+
+            ==================  ===================================
+            Extension           Writer Class
+            ==================  ===================================
+            ``".adoc"``         :py:class:`~.AsciiDocTableWriter`
+            ``".asciidoc"``     :py:class:`~.AsciiDocTableWriter`
+            ``".asc"``          :py:class:`~.AsciiDocTableWriter`
+            ``".css"``          :py:class:`~.CssTableWriter`
+            ``".csv"``          :py:class:`~.CsvTableWriter`
+            ``".htm"``          :py:class:`~.HtmlTableWriter`
+            ``".html"``         :py:class:`~.HtmlTableWriter`
+            ``".js"``           :py:class:`~.JavaScriptTableWriter`
+            ``".json"``         :py:class:`~.JsonTableWriter`
+            ``".jsonl"``        :py:class:`~.JsonLinesTableWriter`
+            ``".ltsv"``         :py:class:`~.LtsvTableWriter`
+            ``".ldjson"``       :py:class:`~.JsonLinesTableWriter`
+            ``".md"``           :py:class:`~.MarkdownTableWriter`
+            ``".ndjson"``       :py:class:`~.JsonLinesTableWriter`
+            ``".py"``           :py:class:`~.PythonCodeTableWriter`
+            ``".rst"``          :py:class:`~.RstGridTableWriter`
+            ``".tsv"``          :py:class:`~.TsvTableWriter`
+            ``".xls"``          :py:class:`~.ExcelXlsTableWriter`
+            ``".xlsx"``         :py:class:`~.ExcelXlsxTableWriter`
+            ``".sqlite"``       :py:class:`~.SqliteTableWriter`
+            ``".sqlite3"``      :py:class:`~.SqliteTableWriter`
+            ``".tsv"``          :py:class:`~.TsvTableWriter`
+            ``".toml"``         :py:class:`~.TomlTableWriter`
+            ``".yml"``          :py:class:`~.YamlTableWriter`
+            ==================  ===================================
+
+        :param str file_extension:
+            File extension string (case insensitive).
+        :param kwargs:
+            Keyword arguments that pass to a writer class constructor.
+        :return:
+            Writer instance that coincides with the ``file_extension``.
+        :rtype:
+            :py:class:`~pytablewriter.writer._table_writer.TableWriterInterface`
+        :raises pytablewriter.WriterNotFoundError:
+            |WriterNotFoundError_desc| the file extension.
+        """
+
+        ext = os.path.splitext(file_extension)[1]
+        if typepy.is_null_string(ext):
+            file_extension = file_extension
+        else:
+            file_extension = ext
+
+        file_extension = file_extension.lstrip(".").lower()
+
+        for table_format in TableFormat:
+            if file_extension not in table_format.file_extensions:
+                continue
+
+            if table_format.format_attribute & FormatAttr.SECONDARY_EXT:
+                continue
+
+            logger.debug(f"create a {table_format.writer_class} instance")
+
+            return table_format.writer_class(**kwargs)  # type: ignore
+
+        raise WriterNotFoundError(
+            "\n".join(
+                [
+                    f"{file_extension:s} (unknown file extension).",
+                    "",
+                    "acceptable file extensions are: {}.".format(", ".join(cls.get_extensions())),
+                ]
+            )
+        )
+
+    @classmethod
+    def create_from_format_name(cls, format_name: str, **kwargs: Any) -> AbstractTableWriter:
+        """
+        Create a table writer class instance from a format name.
+        Supported file format names are as follows:
+
+            =============================================  ===================================
+            Format name                                    Writer Class
+            =============================================  ===================================
+            ``"adoc"``                                     :py:class:`~.AsciiDocTableWriter`
+            ``"asciidoc"``                                 :py:class:`~.AsciiDocTableWriter`
+            ``"css"``                                      :py:class:`~.CssTableWriter`
+            ``"csv"``                                      :py:class:`~.CsvTableWriter`
+            ``"elasticsearch"``                            :py:class:`~.ElasticsearchWriter`
+            ``"excel"``                                    :py:class:`~.ExcelXlsxTableWriter`
+            ``"html"``/``"htm"``                           :py:class:`~.HtmlTableWriter`
+            ``"javascript"``/``"js"``                      :py:class:`~.JavaScriptTableWriter`
+            ``"json"``                                     :py:class:`~.JsonTableWriter`
+            ``"json_lines"``                               :py:class:`~.JsonLinesTableWriter`
+            ``"latex_matrix"``                             :py:class:`~.LatexMatrixWriter`
+            ``"latex_table"``                              :py:class:`~.LatexTableWriter`
+            ``"ldjson"``                                   :py:class:`~.JsonLinesTableWriter`
+            ``"ltsv"``                                     :py:class:`~.LtsvTableWriter`
+            ``"markdown"``/``"md"``                        :py:class:`~.MarkdownTableWriter`
+            ``"mediawiki"``                                :py:class:`~.MediaWikiTableWriter`
+            ``"null"``                                     :py:class:`~.NullTableWriter`
+            ``"pandas"``                                   :py:class:`~.PandasDataFrameWriter`
+            ``"py"``/``"python"``                          :py:class:`~.PythonCodeTableWriter`
+            ``"rst"``/``"rst_grid"``/``"rst_grid_table"``  :py:class:`~.RstGridTableWriter`
+            ``"rst_simple"``/``"rst_simple_table"``        :py:class:`~.RstSimpleTableWriter`
+            ``"rst_csv"``/``"rst_csv_table"``              :py:class:`~.RstCsvTableWriter`
+            ``"sqlite"``                                   :py:class:`~.SqliteTableWriter`
+            ``"ssv"``                                      :py:class:`~.SpaceAlignedTableWriter`
+            ``"tsv"``                                      :py:class:`~.TsvTableWriter`
+            ``"toml"``                                     :py:class:`~.TomlTableWriter`
+            ``"unicode"``                                  :py:class:`~.UnicodeTableWriter`
+            ``"yaml"``                                     :py:class:`~.YamlTableWriter`
+            =============================================  ===================================
+
+        :param str format_name:
+            Format name string (case insensitive).
+        :param kwargs:
+            Keyword arguments that pass to a writer class constructor.
+        :return:
+            Writer instance that coincides with the ``format_name``:
+        :rtype:
+            :py:class:`~pytablewriter.writer._table_writer.TableWriterInterface`
+        :raises pytablewriter.WriterNotFoundError:
+            |WriterNotFoundError_desc| for the format.
+        """
+
+        format_name = format_name.casefold()
+
+        for table_format in TableFormat:
+            if format_name in table_format.names and not (
+                table_format.format_attribute & FormatAttr.SECONDARY_NAME
+            ):
+                writer = table_format.writer_class(**kwargs)  # type: ignore
+                logger.debug(f"create a {writer.FORMAT_NAME} instance")
+
+                return writer
+
+        raise WriterNotFoundError(
+            "\n".join(
+                [
+                    f"{format_name} (unknown format name).",
+                    "acceptable format names are: {}.".format(", ".join(cls.get_format_names())),
+                ]
+            )
+        )
+
+    @classmethod
+    def get_format_names(cls) -> List[str]:
+        """
+        :return: Available format names.
+        :rtype: list
+
+        :Example:
+            .. code:: python
+
+                >>> import pytablewriter as ptw
+                >>> for name in ptw.TableWriterFactory.get_format_names():
+                ...     print(name)
+                ...
+                adoc
+                asciidoc
+                bold_unicode
+                borderless
+                css
+                csv
+                elasticsearch
+                excel
+                htm
+                html
+                javascript
+                js
+                json
+                json_lines
+                jsonl
+                latex_matrix
+                latex_table
+                ldjson
+                ltsv
+                markdown
+                md
+                mediawiki
+                ndjson
+                null
+                numpy
+                pandas
+                pandas_pickle
+                py
+                python
+                rst
+                rst_csv
+                rst_csv_table
+                rst_grid
+                rst_grid_table
+                rst_simple
+                rst_simple_table
+                space_aligned
+                sqlite
+                ssv
+                toml
+                tsv
+                unicode
+                yaml
+
+        """
+
+        return sorted(list(set(chain(*(table_format.names for table_format in TableFormat)))))
+
+    @classmethod
+    def get_extensions(cls) -> List[str]:
+        """
+        :return: Available file extensions.
+        :rtype: list
+
+        :Example:
+            .. code:: python
+
+                >>> import pytablewriter as ptw
+                >>> for name in ptw.TableWriterFactory.get_extensions():
+                ...     print(name)
+                ...
+                adoc
+                asc
+                asciidoc
+                css
+                csv
+                htm
+                html
+                js
+                json
+                jsonl
+                ldjson
+                ltsv
+                md
+                ndjson
+                py
+                rst
+                sqlite
+                sqlite3
+                tex
+                toml
+                tsv
+                xls
+                xlsx
+                yml
+        """
+
+        file_extension_set = set()
+        for table_format in TableFormat:
+            for file_extension in table_format.file_extensions:
+                file_extension_set.add(file_extension)
+
+        return sorted(list(file_extension_set))

llmeval-env/lib/python3.10/site-packages/pytablewriter/_function.py

@@ -0,0 +1,84 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+from datetime import datetime
+from enum import Enum
+from typing import Any, Optional, Type
+
+import dataproperty
+from pathvalidate import replace_symbol
+from tabledata._core import TableData
+
+
+def quote_datetime_formatter(value: datetime) -> str:
+    return f'"{value.strftime(dataproperty.DefaultValue.DATETIME_FORMAT):s}"'
+
+
+def dateutil_datetime_formatter(value: datetime) -> str:
+    return 'dateutil.parser.parse("{:s}")'.format(
+        value.strftime(dataproperty.DefaultValue.DATETIME_FORMAT)
+    )
+
+
+def dumps_tabledata(value: TableData, format_name: str = "rst_grid_table", **kwargs: Any) -> str:
+    """
+    :param tabledata.TableData value: Tabular data to dump.
+    :param str format_name:
+        Dumped format name of tabular data.
+        Available formats are described in
+        :py:meth:`~pytablewriter.TableWriterFactory.create_from_format_name`
+
+    :Example:
+        .. code:: python
+
+            >>> dumps_tabledata(value)
+            .. table:: sample_data
+
+                ======  ======  ======
+                attr_a  attr_b  attr_c
+                ======  ======  ======
+                     1     4.0  a
+                     2     2.1  bb
+                     3   120.9  ccc
+                ======  ======  ======
+    """
+
+    from ._factory import TableWriterFactory
+
+    if not value:
+        raise TypeError("value must be a tabledata.TableData instance")
+
+    writer = TableWriterFactory.create_from_format_name(format_name)
+
+    for attr_name, attr_value in kwargs.items():
+        setattr(writer, attr_name, attr_value)
+
+    writer.from_tabledata(value)
+
+    return writer.dumps()
+
+
+def normalize_enum(
+    value: Any, enum_class: Type[Enum], validate: bool = True, default: Optional[Enum] = None
+) -> Any:
+    if value is None:
+        return default
+
+    if isinstance(value, enum_class):
+        return value
+
+    try:
+        return enum_class[replace_symbol(value.strip(), "_").upper()]
+    except AttributeError:
+        if validate:
+            raise TypeError(f"value must be a {enum_class} or a str: actual={type(value)}")
+    except KeyError:
+        if validate:
+            raise ValueError(
+                "invalid valid found: expected={}, actual={}".format(
+                    "/".join(item.name for item in enum_class), value
+                )
+            )
+
+    return value

llmeval-env/lib/python3.10/site-packages/pytablewriter/_table_format.py

@@ -0,0 +1,353 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+import enum
+from typing import List, Optional, Sequence
+
+from .writer import (
+    AbstractTableWriter,
+    AsciiDocTableWriter,
+    BoldUnicodeTableWriter,
+    BorderlessTableWriter,
+    CssTableWriter,
+    CsvTableWriter,
+    ElasticsearchWriter,
+    ExcelXlsTableWriter,
+    ExcelXlsxTableWriter,
+    HtmlTableWriter,
+    JavaScriptTableWriter,
+    JsonLinesTableWriter,
+    JsonTableWriter,
+    LatexMatrixWriter,
+    LatexTableWriter,
+    LtsvTableWriter,
+    MarkdownTableWriter,
+    MediaWikiTableWriter,
+    NullTableWriter,
+    NumpyTableWriter,
+    PandasDataFramePickleWriter,
+    PandasDataFrameWriter,
+    PythonCodeTableWriter,
+    RstCsvTableWriter,
+    RstGridTableWriter,
+    RstSimpleTableWriter,
+    SpaceAlignedTableWriter,
+    SqliteTableWriter,
+    TomlTableWriter,
+    TsvTableWriter,
+    UnicodeTableWriter,
+    YamlTableWriter,
+)
+
+
+class FormatAttr:
+    """
+    Bitmaps to represent table attributes.
+    """
+
+    NONE = 1 << 1
+
+    #: Can create a file with the format.
+    FILE = 1 << 2
+
+    #: Table format that can represent as a text.
+    TEXT = 1 << 3
+
+    #: Table format that can represent as a binary file.
+    BIN = 1 << 4
+
+    #: Can create a source code (variables definition)
+    #: one of the programming language.
+    SOURCECODE = 1 << 5
+
+    #: Can call API for external service.
+    API = 1 << 6
+
+    SECONDARY_EXT = 1 << 10
+    SECONDARY_NAME = 1 << 11
+
+
+@enum.unique
+class TableFormat(enum.Enum):
+    """
+    Enum to represent table format attributes.
+    """
+
+    ASCIIDOC = (
+        [AsciiDocTableWriter.FORMAT_NAME, "adoc"],
+        AsciiDocTableWriter,
+        FormatAttr.FILE | FormatAttr.TEXT,
+        ["adoc", "asciidoc", "asc"],
+    )
+    CSV = ([CsvTableWriter.FORMAT_NAME], CsvTableWriter, FormatAttr.FILE | FormatAttr.TEXT, ["csv"])
+    CSS = (
+        [CssTableWriter.FORMAT_NAME],
+        CssTableWriter,
+        FormatAttr.FILE | FormatAttr.TEXT,
+        ["css"],
+    )
+    ELASTICSEARCH = (
+        [ElasticsearchWriter.FORMAT_NAME],  # type: ignore
+        ElasticsearchWriter,
+        FormatAttr.API,
+        [],
+    )
+    EXCEL_XLSX = (
+        [ExcelXlsxTableWriter.FORMAT_NAME],
+        ExcelXlsxTableWriter,
+        FormatAttr.FILE | FormatAttr.BIN,
+        ["xlsx"],
+    )
+    EXCEL_XLS = (
+        [ExcelXlsTableWriter.FORMAT_NAME],
+        ExcelXlsTableWriter,
+        FormatAttr.FILE | FormatAttr.BIN | FormatAttr.SECONDARY_NAME,
+        ["xls"],
+    )
+    HTML = (
+        [HtmlTableWriter.FORMAT_NAME, "htm"],
+        HtmlTableWriter,
+        FormatAttr.FILE | FormatAttr.TEXT,
+        ["html", "htm"],
+    )
+    JAVASCRIPT = (
+        [JavaScriptTableWriter.FORMAT_NAME, "js"],
+        JavaScriptTableWriter,
+        FormatAttr.FILE | FormatAttr.TEXT | FormatAttr.SOURCECODE,
+        ["js"],
+    )
+    JSON = (
+        [JsonTableWriter.FORMAT_NAME],
+        JsonTableWriter,
+        FormatAttr.FILE | FormatAttr.TEXT,
+        ["json"],
+    )
+    JSON_LINES = (
+        [JsonLinesTableWriter.FORMAT_NAME, "jsonl", "ldjson", "ndjson"],
+        JsonLinesTableWriter,
+        FormatAttr.FILE | FormatAttr.TEXT,
+        ["jsonl", "ldjson", "ndjson"],
+    )
+    LATEX_MATRIX = (
+        [LatexMatrixWriter.FORMAT_NAME],
+        LatexMatrixWriter,
+        FormatAttr.FILE | FormatAttr.TEXT,
+        ["tex"],
+    )
+    LATEX_TABLE = (
+        [LatexTableWriter.FORMAT_NAME],
+        LatexTableWriter,
+        FormatAttr.FILE | FormatAttr.TEXT | FormatAttr.SECONDARY_EXT,
+        ["tex"],
+    )
+    LTSV = (
+        [LtsvTableWriter.FORMAT_NAME],
+        LtsvTableWriter,
+        FormatAttr.FILE | FormatAttr.TEXT,
+        ["ltsv"],
+    )
+    MARKDOWN = (
+        [MarkdownTableWriter.FORMAT_NAME, "md"],
+        MarkdownTableWriter,
+        FormatAttr.FILE | FormatAttr.TEXT,
+        ["md"],
+    )
+    MEDIAWIKI = (
+        [MediaWikiTableWriter.FORMAT_NAME],  # type: ignore
+        MediaWikiTableWriter,
+        FormatAttr.FILE | FormatAttr.TEXT,
+        [],
+    )
+    NULL = (
+        [NullTableWriter.FORMAT_NAME],  # type: ignore
+        NullTableWriter,
+        FormatAttr.NONE,
+        [],
+    )
+    NUMPY = (
+        [NumpyTableWriter.FORMAT_NAME],
+        NumpyTableWriter,
+        FormatAttr.FILE | FormatAttr.TEXT | FormatAttr.SOURCECODE | FormatAttr.SECONDARY_EXT,
+        ["py"],
+    )
+    PANDAS = (
+        [PandasDataFrameWriter.FORMAT_NAME],
+        PandasDataFrameWriter,
+        FormatAttr.FILE | FormatAttr.TEXT | FormatAttr.SOURCECODE | FormatAttr.SECONDARY_EXT,
+        ["py"],
+    )
+    PANDAS_PICKLE = (
+        [PandasDataFramePickleWriter.FORMAT_NAME],  # type: ignore
+        PandasDataFramePickleWriter,
+        FormatAttr.FILE | FormatAttr.BIN,
+        [],
+    )
+    PYTHON = (
+        [PythonCodeTableWriter.FORMAT_NAME, "py"],
+        PythonCodeTableWriter,
+        FormatAttr.FILE | FormatAttr.TEXT | FormatAttr.SOURCECODE,
+        ["py"],
+    )
+    RST_CSV_TABLE = (
+        [RstCsvTableWriter.FORMAT_NAME, "rst_csv"],
+        RstCsvTableWriter,
+        FormatAttr.FILE | FormatAttr.TEXT | FormatAttr.SECONDARY_EXT,
+        ["rst"],
+    )
+    RST_GRID_TABLE = (
+        [RstGridTableWriter.FORMAT_NAME, "rst_grid", "rst"],
+        RstGridTableWriter,
+        FormatAttr.FILE | FormatAttr.TEXT,
+        ["rst"],
+    )
+    RST_SIMPLE_TABLE = (
+        [RstSimpleTableWriter.FORMAT_NAME, "rst_simple"],
+        RstSimpleTableWriter,
+        FormatAttr.FILE | FormatAttr.TEXT | FormatAttr.SECONDARY_EXT,
+        ["rst"],
+    )
+    SPACE_ALIGNED = (
+        [SpaceAlignedTableWriter.FORMAT_NAME, "ssv"],  # type: ignore
+        SpaceAlignedTableWriter,
+        FormatAttr.FILE | FormatAttr.TEXT,
+        [],
+    )
+    SQLITE = (
+        [SqliteTableWriter.FORMAT_NAME],
+        SqliteTableWriter,
+        FormatAttr.FILE | FormatAttr.BIN,
+        ["sqlite", "sqlite3"],
+    )
+    TOML = (
+        [TomlTableWriter.FORMAT_NAME],
+        TomlTableWriter,
+        FormatAttr.FILE | FormatAttr.TEXT,
+        ["toml"],
+    )
+    TSV = ([TsvTableWriter.FORMAT_NAME], TsvTableWriter, FormatAttr.FILE | FormatAttr.TEXT, ["tsv"])
+    UNICODE = (
+        [UnicodeTableWriter.FORMAT_NAME],  # type: ignore
+        UnicodeTableWriter,
+        FormatAttr.TEXT,
+        [],
+    )
+    YAML = (
+        [YamlTableWriter.FORMAT_NAME],
+        YamlTableWriter,
+        FormatAttr.FILE | FormatAttr.TEXT,
+        ["yml"],
+    )
+    BOLD_UNICODE = (
+        [BoldUnicodeTableWriter.FORMAT_NAME],  # type: ignore
+        BoldUnicodeTableWriter,
+        FormatAttr.TEXT,
+        [],
+    )
+    BORDERLESS = (
+        [BorderlessTableWriter.FORMAT_NAME],  # type: ignore
+        BorderlessTableWriter,
+        FormatAttr.TEXT,
+        [],
+    )
+
+    @property
+    def names(self) -> List[str]:
+        """
+        List[str]: Names associated with the table format.
+        """
+
+        return self.__names
+
+    @property
+    def writer_class(self) -> AbstractTableWriter:
+        """
+        Type[AbstractTableWriter]: Table writer class object associated with the table format.
+        """
+
+        return self.__writer_class
+
+    @property
+    def format_attribute(self) -> int:
+        """
+        FormatAttr: Table attributes bitmap.
+        """
+
+        return self.__format_attribute
+
+    @property
+    def file_extensions(self) -> List[str]:
+        """
+        List[str]: File extensions associated with the table format.
+        """
+
+        return self.__file_extensions
+
+    def __init__(
+        self,
+        names: Sequence[str],
+        writer_class: AbstractTableWriter,
+        format_attribute: int,
+        file_extensions: Sequence[str],
+    ) -> None:
+        self.__names = list(names)
+        self.__writer_class = writer_class
+        self.__format_attribute = format_attribute
+        self.__file_extensions = list(file_extensions)
+
+    @classmethod
+    def find_all_attr(cls, format_attribute: int) -> List["TableFormat"]:
+        """Searching table formats that have specific attributes.
+
+        Args:
+            format_attribute (FormatAttr):
+                Table format attributes to look for.
+
+        Returns:
+            List[TableFormat]: Table formats that matched the attribute.
+        """
+
+        return [
+            table_format
+            for table_format in TableFormat
+            if table_format.format_attribute & format_attribute
+        ]
+
+    @classmethod
+    def from_name(cls, format_name: str) -> Optional["TableFormat"]:
+        """Get a table format from a format name.
+
+        Args:
+            format_name (str): Table format specifier.
+
+        Returns:
+            Optional[TableFormat]: A table format enum value corresponding to the ``format_name``.
+        """
+
+        format_name = format_name.casefold().strip()
+
+        for table_format in TableFormat:
+            if format_name in table_format.names:
+                return table_format
+
+        return None
+
+    @classmethod
+    def from_file_extension(cls, file_extension: str) -> Optional["TableFormat"]:
+        """Get a table format from a file extension.
+
+        Args:
+            file_extension (str): File extension.
+
+        Returns:
+            Optional[TableFormat]:
+                A table format enum value corresponding to the ``file_extension``.
+        """
+
+        ext = file_extension.lower().strip().lstrip(".")
+
+        for table_format in TableFormat:
+            if ext in table_format.file_extensions:
+                return table_format
+
+        return None

llmeval-env/lib/python3.10/site-packages/pytablewriter/error.py

@@ -0,0 +1,34 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+
+class NotSupportedError(Exception):
+    pass
+
+
+class EmptyTableNameError(Exception):
+    """
+    Exception raised when a table writer class of the |table_name| attribute
+    is null and the class is not accepted null |table_name|.
+    """
+
+
+class EmptyValueError(Exception):
+    """
+    Exception raised when a table writer class of the |value_matrix| attribute
+    is null, and the class is not accepted null |value_matrix|.
+    """
+
+
+class EmptyTableDataError(Exception):
+    """
+    Exception raised when a table writer class of the |headers| and
+    |value_matrix| attributes are null.
+    """
+
+
+class WriterNotFoundError(Exception):
+    """
+    Exception raised when appropriate loader writer found.
+    """