Add files using upload-large-folder tool

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

@@ -0,0 +1,45 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+from .__version__ import __author__, __copyright__, __email__, __license__, __version__
+from ._align import Align
+from ._align_getter import align_getter
+from ._column import ColumnDataProperty
+from ._common import MAX_STRICT_LEVEL_MAP, MIN_STRICT_LEVEL_MAP, NOT_QUOTING_FLAGS, DefaultValue
+from ._container import MinMaxContainer
+from ._dataproperty import DataProperty
+from ._extractor import DataPropertyExtractor, DataPropertyMatrix, MatrixFormatting
+from ._formatter import Format
+from ._function import calc_ascii_char_width, get_integer_digit, get_number_of_digit
+from ._line_break import LineBreakHandling
+from ._preprocessor import Preprocessor
+from .logger import set_logger
+
+
+__all__ = (
+    "Align",
+    "align_getter",
+    "ColumnDataProperty",
+    "DataProperty",
+    "DataPropertyExtractor",
+    "DataPropertyMatrix",
+    "Format",
+    "LineBreakHandling",
+    "MatrixFormatting",
+    "MinMaxContainer",
+    "Preprocessor",
+    "calc_ascii_char_width",
+    "get_integer_digit",
+    "get_number_of_digit",
+    "MAX_STRICT_LEVEL_MAP",
+    "MIN_STRICT_LEVEL_MAP",
+    "NOT_QUOTING_FLAGS",
+    "DefaultValue",
+    "set_logger",
+    "__author__",
+    "__copyright__",
+    "__email__",
+    "__license__",
+    "__version__",
+)

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

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

llmeval-env/lib/python3.10/site-packages/dataproperty/_align.py

@@ -0,0 +1,25 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+import enum
+
+
+@enum.unique
+class Align(enum.Enum):
+    AUTO = (1 << 0, "auto")
+    LEFT = (1 << 1, "left")
+    RIGHT = (1 << 2, "right")
+    CENTER = (1 << 3, "center")
+
+    @property
+    def align_code(self) -> int:
+        return self.__align_code
+
+    @property
+    def align_string(self) -> str:
+        return self.__align_string
+
+    def __init__(self, code: int, string: str) -> None:
+        self.__align_code = code
+        self.__align_string = string

llmeval-env/lib/python3.10/site-packages/dataproperty/_align_getter.py

@@ -0,0 +1,33 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+from typing import Dict
+
+from typepy import Typecode
+
+from ._align import Align
+
+
+class AlignGetter:
+    @property
+    def typecode_align_table(self):
+        raise NotImplementedError()
+
+    @typecode_align_table.setter
+    def typecode_align_table(self, x: Dict[Typecode, Align]) -> None:
+        self.__typecode_align_table = x
+
+    def get_align_from_typecode(self, typecode: Typecode) -> Align:
+        return self.__typecode_align_table.get(typecode, self.default_align)
+
+    def __init__(self) -> None:
+        self.typecode_align_table = {
+            Typecode.STRING: Align.LEFT,
+            Typecode.INTEGER: Align.RIGHT,
+            Typecode.REAL_NUMBER: Align.RIGHT,
+        }
+        self.default_align = Align.LEFT
+
+
+align_getter = AlignGetter()

llmeval-env/lib/python3.10/site-packages/dataproperty/_base.py

@@ -0,0 +1,98 @@
+from typing import Dict, Optional, Type
+
+from typepy import (
+    Bool,
+    DateTime,
+    Dictionary,
+    Infinity,
+    Integer,
+    IpAddress,
+    List,
+    Nan,
+    NoneType,
+    NullString,
+    RealNumber,
+    String,
+    Typecode,
+)
+from typepy.type import AbstractType
+
+from ._formatter import Formatter
+from ._interface import DataPeropertyInterface
+
+
+class DataPeropertyBase(DataPeropertyInterface):
+    __slots__ = (
+        "_datetime_format_str",
+        "_decimal_places",
+        "_east_asian_ambiguous_width",
+        "_formatter",
+        "_typecode",
+        "__format_str",
+    )
+
+    __TYPE_CLASS_TABLE: Dict[Typecode, AbstractType] = {
+        Typecode.BOOL: Bool,
+        Typecode.DATETIME: DateTime,
+        Typecode.DICTIONARY: Dictionary,
+        Typecode.INTEGER: Integer,
+        Typecode.INFINITY: Infinity,
+        Typecode.IP_ADDRESS: IpAddress,
+        Typecode.LIST: List,
+        Typecode.NAN: Nan,
+        Typecode.NONE: NoneType,
+        Typecode.NULL_STRING: NullString,
+        Typecode.REAL_NUMBER: RealNumber,
+        Typecode.STRING: String,
+    }
+
+    @property
+    def type_class(self) -> Type[AbstractType]:
+        return self.__TYPE_CLASS_TABLE[self.typecode]
+
+    @property
+    def typecode(self) -> Typecode:
+        """
+        ``typepy.Typecode`` that corresponds to the type of the ``data``.
+
+        :return:
+            One of the Enum value that are defined ``typepy.Typecode``.
+        :rtype: typepy.Typecode
+        """
+
+        assert self._typecode
+
+        return self._typecode
+
+    @property
+    def typename(self) -> str:
+        return self.typecode.name
+
+    def __init__(
+        self,
+        format_flags: Optional[int],
+        is_formatting_float: bool,
+        datetime_format_str: str,
+        east_asian_ambiguous_width: int,
+    ) -> None:
+        self._decimal_places: Optional[int] = None
+        self._east_asian_ambiguous_width = east_asian_ambiguous_width
+        self._typecode: Optional[Typecode] = None
+
+        self._datetime_format_str = datetime_format_str
+        self.__format_str = ""
+
+        self._formatter = Formatter(
+            format_flags=format_flags,
+            datetime_format_str=self._datetime_format_str,
+            is_formatting_float=is_formatting_float,
+        )
+
+    @property
+    def format_str(self) -> str:
+        if self.__format_str:
+            return self.__format_str
+
+        self.__format_str = self._formatter.make_format_str(self.typecode, self.decimal_places)
+
+        return self.__format_str

llmeval-env/lib/python3.10/site-packages/dataproperty/_column.py

@@ -0,0 +1,352 @@
+from typing import Any, Dict, List, Optional
+
+from mbstrdecoder import MultiByteStrDecoder
+from typepy import Integer, StrictLevel, Typecode, TypeConversionError
+
+from ._align import Align
+from ._align_getter import align_getter
+from ._base import DataPeropertyBase
+from ._common import DefaultValue
+from ._container import ListContainer, MinMaxContainer
+from ._dataproperty import DataProperty
+from ._function import calc_ascii_char_width
+from .typing import FloatType
+
+
+class ColumnDataProperty(DataPeropertyBase):
+    __slots__ = (
+        "__header_ascii_char_width",
+        "__body_ascii_char_width",
+        "__column_index",
+        "__dp_list",
+        "__float_type",
+        "__format_map",
+        "__is_calculate",
+        "__max_precision",
+        "__minmax_integer_digits",
+        "__minmax_decimal_places",
+        "__minmax_additional_format_len",
+        "__typecode_bitmap",
+    )
+
+    @property
+    def align(self) -> Align:
+        return align_getter.get_align_from_typecode(self.typecode)
+
+    @property
+    def bit_length(self) -> Optional[int]:
+        if self.typecode != Typecode.INTEGER:
+            return None
+
+        bit_length = 0
+        for value_dp in self.__dp_list:
+            try:
+                bit_length = max(bit_length, int.bit_length(value_dp.data))
+            except TypeError:
+                pass
+
+        return bit_length
+
+    @property
+    def column_index(self) -> int:
+        return self.__column_index
+
+    @property
+    def decimal_places(self) -> Optional[int]:
+        return self._decimal_places
+
+    @property
+    def ascii_char_width(self) -> int:
+        return max(self.__header_ascii_char_width, self.__body_ascii_char_width)
+
+    @property
+    def minmax_integer_digits(self) -> MinMaxContainer:
+        return self.__minmax_integer_digits
+
+    @property
+    def minmax_decimal_places(self) -> ListContainer:
+        return self.__minmax_decimal_places
+
+    @property
+    def minmax_additional_format_len(self) -> MinMaxContainer:
+        return self.__minmax_additional_format_len
+
+    def __init__(
+        self,
+        column_index: int,
+        float_type: Optional[FloatType],
+        min_width: int = 0,
+        format_flags: Optional[int] = None,
+        is_formatting_float: bool = True,
+        datetime_format_str: str = DefaultValue.DATETIME_FORMAT,
+        east_asian_ambiguous_width: int = 1,
+        max_precision: int = DefaultValue.MAX_PRECISION,
+    ) -> None:
+        super().__init__(
+            format_flags=format_flags,
+            is_formatting_float=is_formatting_float,
+            datetime_format_str=datetime_format_str,
+            east_asian_ambiguous_width=east_asian_ambiguous_width,
+        )
+
+        self.__header_ascii_char_width = 0
+        self.__body_ascii_char_width = min_width
+        self.__column_index = column_index
+
+        self.__float_type = float_type
+
+        self.__is_calculate = True
+        self.__dp_list: List[DataProperty] = []
+        self.__minmax_integer_digits = MinMaxContainer()
+        self.__minmax_decimal_places = ListContainer()
+        self.__minmax_additional_format_len = MinMaxContainer()
+        self.__max_precision = max_precision
+
+        self.__typecode_bitmap = Typecode.NONE.value
+        self.__calc_typecode_from_bitmap()
+
+        self.__format_map: Dict[Typecode, str] = self._formatter.make_format_map(
+            decimal_places=self._decimal_places
+        )
+
+    def __repr__(self) -> str:
+        element_list = []
+
+        if self.column_index is not None:
+            element_list.append(f"column={self.column_index}")
+
+        element_list.extend(
+            [
+                f"type={self.typename}",
+                f"align={self.align.align_string}",
+                f"ascii_width={self.ascii_char_width}",
+            ]
+        )
+
+        if Integer(self.bit_length).is_type():
+            element_list.append(f"bit_len={self.bit_length}")
+
+        if self.minmax_integer_digits.has_value():
+            if self.minmax_integer_digits.is_same_value():
+                value = f"int_digits={self.minmax_integer_digits.min_value}"
+            else:
+                value = f"int_digits=({self.minmax_integer_digits})"
+
+            element_list.append(value)
+
+        if self.minmax_decimal_places.has_value():
+            if self.minmax_decimal_places.is_same_value():
+                value = f"decimal_places={self.minmax_decimal_places.min_value}"
+            else:
+                value = f"decimal_places=({self.minmax_decimal_places})"
+
+            element_list.append(value)
+
+        if not self.minmax_additional_format_len.is_zero():
+            if self.minmax_additional_format_len.is_same_value():
+                value = f"extra_len={self.minmax_additional_format_len.min_value}"
+            else:
+                value = f"extra_len=({self.minmax_additional_format_len})"
+
+            element_list.append(value)
+
+        return ", ".join(element_list)
+
+    def dp_to_str(self, value_dp: DataProperty) -> str:
+        if value_dp.typecode == Typecode.STRING:
+            return str(value_dp.data)
+
+        try:
+            value = self.__preprocess_value_before_tostring(value_dp)
+        except TypeConversionError:
+            return self.__format_map.get(value_dp.typecode, "{:s}").format(value_dp.data)
+
+        to_string_format_str = self.__get_tostring_format(value_dp)
+
+        try:
+            return to_string_format_str.format(value)
+        except (ValueError, TypeError):
+            pass
+
+        try:
+            return MultiByteStrDecoder(value).unicode_str
+        except ValueError:
+            pass
+
+        return str(value)
+
+    def extend_width(self, ascii_char_width: int) -> None:
+        self.extend_header_width(ascii_char_width)
+        self.extend_body_width(ascii_char_width)
+
+    def extend_header_width(self, ascii_char_width: int) -> None:
+        self.__header_ascii_char_width += ascii_char_width
+
+    def extend_body_width(self, ascii_char_width: int) -> None:
+        self.__body_ascii_char_width += ascii_char_width
+
+    def update_header(self, header_db: DataProperty) -> None:
+        self.__header_ascii_char_width = header_db.ascii_char_width
+
+    def update_body(self, value_dp: DataProperty) -> None:
+        if value_dp.is_include_ansi_escape:
+            assert value_dp.no_ansi_escape_dp
+            value_dp = value_dp.no_ansi_escape_dp
+
+        self.__typecode_bitmap |= value_dp.typecode.value
+        self.__calc_typecode_from_bitmap()
+
+        if value_dp.typecode in (Typecode.REAL_NUMBER, Typecode.INTEGER):
+            self.__minmax_integer_digits.update(value_dp.integer_digits)
+            self.__minmax_decimal_places.update(value_dp.decimal_places)
+            self.__update_decimal_places()
+
+        self.__minmax_additional_format_len.update(value_dp.additional_format_len)
+
+        self.__dp_list.append(value_dp)
+        self.__update_ascii_char_width()
+
+    def merge(self, column_dp: "ColumnDataProperty") -> None:
+        self.__typecode_bitmap |= column_dp.typecode.value
+        self.__calc_typecode_from_bitmap()
+
+        self.__minmax_integer_digits.merge(column_dp.minmax_integer_digits)
+        self.__minmax_decimal_places.merge(column_dp.minmax_decimal_places)
+        self.__update_decimal_places()
+
+        self.__minmax_additional_format_len.merge(column_dp.minmax_additional_format_len)
+
+        self.__body_ascii_char_width = max(self.__body_ascii_char_width, column_dp.ascii_char_width)
+        self.__update_ascii_char_width()
+
+    def begin_update(self) -> None:
+        self.__is_calculate = False
+
+    def end_update(self) -> None:
+        self.__is_calculate = True
+
+        self.__calc_typecode_from_bitmap()
+        self.__update_decimal_places()
+        self.__update_ascii_char_width()
+
+    def __is_not_single_typecode(self, typecode_bitmap: int) -> bool:
+        return bool(
+            self.__typecode_bitmap & typecode_bitmap and self.__typecode_bitmap & ~typecode_bitmap
+        )
+
+    def __is_float_typecode(self) -> bool:
+        FLOAT_TYPECODE_BMP = (
+            Typecode.REAL_NUMBER.value | Typecode.INFINITY.value | Typecode.NAN.value
+        )
+        NUMBER_TYPECODE_BMP = FLOAT_TYPECODE_BMP | Typecode.INTEGER.value
+
+        if self.__is_not_single_typecode(NUMBER_TYPECODE_BMP | Typecode.NULL_STRING.value):
+            return False
+
+        if (
+            bin(self.__typecode_bitmap & (FLOAT_TYPECODE_BMP | Typecode.NULL_STRING.value)).count(
+                "1"
+            )
+            >= 2
+        ):
+            return True
+
+        if bin(self.__typecode_bitmap & NUMBER_TYPECODE_BMP).count("1") >= 2:
+            return True
+
+        return False
+
+    def __calc_body_ascii_char_width(self) -> int:
+        width_list = [self.__body_ascii_char_width]
+
+        for value_dp in self.__dp_list:
+            if value_dp.is_include_ansi_escape:
+                assert value_dp.no_ansi_escape_dp
+                value_dp = value_dp.no_ansi_escape_dp
+
+            width_list.append(
+                calc_ascii_char_width(self.dp_to_str(value_dp), self._east_asian_ambiguous_width)
+            )
+
+        return max(width_list)
+
+    def __calc_decimal_places(self) -> Optional[int]:
+        if self.minmax_decimal_places.max_value is None:
+            return None
+
+        return min(self.__max_precision, int(self.minmax_decimal_places.max_value))
+
+    def __get_tostring_format(self, value_dp: DataProperty) -> str:
+        if self.typecode == Typecode.STRING:
+            return self.__format_map.get(value_dp.typecode, "{:s}")
+
+        return self.__format_map.get(self.typecode, "{:s}")
+
+    def __get_typecode_from_bitmap(self) -> Typecode:
+        if self.__is_float_typecode():
+            return Typecode.REAL_NUMBER
+
+        if any(
+            [
+                self.__is_not_single_typecode(Typecode.BOOL.value),
+                self.__is_not_single_typecode(Typecode.DATETIME.value),
+            ]
+        ):
+            return Typecode.STRING
+
+        typecode_list = [
+            Typecode.STRING,
+            Typecode.REAL_NUMBER,
+            Typecode.INTEGER,
+            Typecode.DATETIME,
+            Typecode.DICTIONARY,
+            Typecode.IP_ADDRESS,
+            Typecode.LIST,
+            Typecode.BOOL,
+            Typecode.INFINITY,
+            Typecode.NAN,
+            Typecode.NULL_STRING,
+        ]
+
+        for typecode in typecode_list:
+            if self.__typecode_bitmap & typecode.value:
+                return typecode
+
+        if self.__typecode_bitmap == Typecode.NONE.value:
+            return Typecode.NONE
+
+        return Typecode.STRING
+
+    def __update_ascii_char_width(self) -> None:
+        if not self.__is_calculate:
+            return
+
+        self.__body_ascii_char_width = self.__calc_body_ascii_char_width()
+
+    def __update_decimal_places(self) -> None:
+        if not self.__is_calculate:
+            return
+
+        self._decimal_places = self.__calc_decimal_places()
+        self.__format_map = self._formatter.make_format_map(decimal_places=self._decimal_places)
+
+    def __calc_typecode_from_bitmap(self) -> None:
+        if not self.__is_calculate:
+            return
+
+        self._typecode = self.__get_typecode_from_bitmap()
+
+    def __preprocess_value_before_tostring(self, value_dp: DataProperty) -> Any:
+        if self.typecode == value_dp.typecode or self.typecode in [
+            Typecode.STRING,
+            Typecode.BOOL,
+            Typecode.DATETIME,
+        ]:
+            return value_dp.data
+
+        return self.type_class(
+            value_dp.data,
+            strict_level=StrictLevel.MIN,
+            float_type=self.__float_type,
+            strip_ansi_escape=False,
+        ).convert()

llmeval-env/lib/python3.10/site-packages/dataproperty/_common.py

@@ -0,0 +1,69 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+import copy
+import itertools
+from datetime import datetime
+from decimal import Decimal
+
+from typepy import StrictLevel, Typecode
+
+from .typing import StrictLevelMap, TypeValueMap
+
+
+NOT_QUOTING_FLAGS = {
+    Typecode.BOOL: False,
+    Typecode.DATETIME: False,
+    Typecode.DICTIONARY: False,
+    Typecode.INFINITY: False,
+    Typecode.INTEGER: False,
+    Typecode.IP_ADDRESS: False,
+    Typecode.LIST: False,
+    Typecode.NAN: False,
+    Typecode.NULL_STRING: False,
+    Typecode.NONE: False,
+    Typecode.REAL_NUMBER: False,
+    Typecode.STRING: False,
+}
+
+MAX_STRICT_LEVEL_MAP: StrictLevelMap = dict(itertools.product(list(Typecode), [StrictLevel.MAX]))
+MIN_STRICT_LEVEL_MAP: StrictLevelMap = dict(itertools.product(list(Typecode), [StrictLevel.MIN]))
+
+
+class DefaultValue:
+    DATETIME_FORMAT = "%Y-%m-%dT%H:%M:%S%z"
+    FLOAT_TYPE = Decimal
+    INF_VALUE = FLOAT_TYPE("inf")
+    NAN_VALUE = FLOAT_TYPE("nan")
+
+    QUOTING_FLAGS = copy.deepcopy(NOT_QUOTING_FLAGS)
+
+    STRICT_LEVEL_MAP: StrictLevelMap = {
+        "default": StrictLevel.MAX,
+        Typecode.BOOL: StrictLevel.MAX,
+        Typecode.DATETIME: StrictLevel.MAX,
+        Typecode.DICTIONARY: StrictLevel.MAX,
+        Typecode.REAL_NUMBER: 1,
+        Typecode.INFINITY: StrictLevel.MIN,
+        Typecode.INTEGER: 1,
+        Typecode.IP_ADDRESS: StrictLevel.MAX,
+        Typecode.LIST: StrictLevel.MAX,
+        Typecode.NAN: StrictLevel.MIN,
+        Typecode.NONE: StrictLevel.MAX,
+        Typecode.NULL_STRING: StrictLevel.MIN,
+        Typecode.STRING: StrictLevel.MIN,
+    }
+
+    TYPE_VALUE_MAP: TypeValueMap = {
+        Typecode.NONE: None,
+        Typecode.INFINITY: INF_VALUE,
+        Typecode.NAN: NAN_VALUE,
+    }
+
+    MAX_WORKERS = 1
+    MAX_PRECISION = 100
+
+
+def default_datetime_formatter(value: datetime) -> str:
+    return value.strftime(DefaultValue.DATETIME_FORMAT)

llmeval-env/lib/python3.10/site-packages/dataproperty/_container.py

@@ -0,0 +1,193 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+import abc
+from decimal import Decimal
+from typing import Any, List, Optional, Sequence, Union
+
+from typepy import RealNumber
+
+
+T = Union[int, float, Decimal]
+NAN = Decimal("nan")
+
+
+class AbstractContainer(metaclass=abc.ABCMeta):
+    @abc.abstractproperty
+    def min_value(self) -> Optional[Decimal]:  # pragma: no cover
+        pass
+
+    @abc.abstractproperty
+    def max_value(self) -> Optional[Decimal]:  # pragma: no cover
+        pass
+
+    @abc.abstractmethod
+    def mean(self) -> Decimal:  # pragma: no cover
+        pass
+
+    @abc.abstractmethod
+    def update(self, value: Optional[T]) -> None:  # pragma: no cover
+        pass
+
+    @abc.abstractmethod
+    def merge(self, value: "AbstractContainer") -> None:  # pragma: no cover
+        pass
+
+    def __repr__(self) -> str:
+        if not self.has_value():
+            return "None"
+
+        return ", ".join([f"min={self.min_value}", f"max={self.max_value}"])
+
+    def has_value(self) -> bool:
+        return self.min_value is not None and self.max_value is not None
+
+    def is_same_value(self) -> bool:
+        return self.has_value() and self.min_value == self.max_value
+
+    def is_zero(self) -> bool:
+        return self.has_value() and self.min_value == 0 and self.max_value == 0
+
+
+class ListContainer(AbstractContainer):
+    __slots__ = ("__value_list",)
+
+    @property
+    def min_value(self) -> Optional[Decimal]:
+        try:
+            return min(self.__value_list)
+        except ValueError:
+            return None
+
+    @property
+    def max_value(self) -> Optional[Decimal]:
+        try:
+            return max(self.__value_list)
+        except ValueError:
+            return None
+
+    @property
+    def value_list(self) -> List[Decimal]:
+        return self.__value_list
+
+    def __init__(self, value_list: Optional[List[Decimal]] = None) -> None:
+        if value_list is None:
+            self.__value_list: List[Decimal] = []
+            return
+
+        for value in value_list:
+            self.update(value)
+
+    def mean(self) -> Decimal:
+        try:
+            return Decimal(sum(self.__value_list) / len(self.__value_list))
+        except ZeroDivisionError:
+            return NAN
+
+    def update(self, value: Union[int, float, Decimal, None]) -> None:
+        if value is None:
+            return
+
+        store_value = RealNumber(value).try_convert()
+        if store_value is None:
+            return
+
+        self.__value_list.append(store_value)
+
+    def merge(self, value: "AbstractContainer") -> None:
+        if not isinstance(value, ListContainer):
+            return
+
+        for v in value.value_list:
+            self.update(v)
+
+
+class MinMaxContainer(AbstractContainer):
+    __slots__ = ("__min_value", "__max_value")
+
+    def __init__(self, value_list: Optional[Sequence[Decimal]] = None) -> None:
+        self.__min_value: Optional[Decimal] = None
+        self.__max_value: Optional[Decimal] = None
+
+        if value_list is None:
+            return
+
+        for value in value_list:
+            self.update(value)
+
+    @property
+    def min_value(self) -> Optional[Decimal]:
+        return self.__min_value
+
+    @property
+    def max_value(self) -> Optional[Decimal]:
+        return self.__max_value
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, MinMaxContainer):
+            return False
+
+        return all([self.min_value == other.min_value, self.max_value == other.max_value])
+
+    def __ne__(self, other: Any) -> bool:
+        if not isinstance(other, MinMaxContainer):
+            return True
+
+        return any([self.min_value != other.min_value, self.max_value != other.max_value])
+
+    def __contains__(self, x: T) -> bool:
+        if self.min_value is None:
+            return False
+
+        if self.max_value is None:
+            return False
+
+        return self.min_value <= x <= self.max_value
+
+    def diff(self) -> Decimal:
+        if self.min_value is None:
+            return NAN
+
+        if self.max_value is None:
+            return NAN
+
+        try:
+            return self.max_value - self.min_value
+        except TypeError:
+            return NAN
+
+    def mean(self) -> Decimal:
+        if self.min_value is None:
+            return NAN
+
+        if self.max_value is None:
+            return NAN
+
+        try:
+            return (self.max_value + self.min_value) * Decimal("0.5")
+        except TypeError:
+            return NAN
+
+    def update(self, value: Optional[T]) -> None:
+        if value is None:
+            return
+
+        decimal_value = Decimal(value)
+
+        if self.__min_value is None:
+            self.__min_value = decimal_value
+        else:
+            self.__min_value = min(self.__min_value, decimal_value)
+
+        if self.__max_value is None:
+            self.__max_value = decimal_value
+        else:
+            self.__max_value = max(self.__max_value, decimal_value)
+
+    def merge(self, value: "AbstractContainer") -> None:
+        if not isinstance(value, MinMaxContainer):
+            return
+
+        self.update(value.min_value)
+        self.update(value.max_value)

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

@@ -0,0 +1,90 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+import re
+from typing import Any, Dict, Optional
+
+from typepy import Typecode, TypeConversionError
+
+from ._common import MAX_STRICT_LEVEL_MAP, DefaultValue
+from ._dataproperty import DataProperty
+from ._preprocessor import Preprocessor
+from .typing import DateTimeFormatter, FloatType, StrictLevelMap, TypeValueMap
+
+
+class DataPropertyConverter:
+    __RE_QUOTE_LINE = re.compile(r"^\s*[\"'].*[\"']\s*$")  # noqa: w605
+    __RE_QUOTE_CHAR = re.compile("[\"']")
+
+    def __init__(
+        self,
+        preprocessor: Preprocessor,
+        datetime_format_str: str,
+        datetime_formatter: Optional[DateTimeFormatter] = None,
+        type_value_map: Optional[TypeValueMap] = None,
+        quoting_flags: Optional[Dict[Typecode, bool]] = None,
+        float_type: Optional[FloatType] = None,
+        strict_level_map: Optional[StrictLevelMap] = None,
+    ) -> None:
+        self.__preprocessor = preprocessor
+        self.__type_value_map: TypeValueMap = (
+            type_value_map if type_value_map else DefaultValue.TYPE_VALUE_MAP
+        )
+        self.__quoting_flags: Dict[Typecode, bool] = (
+            quoting_flags if quoting_flags else DefaultValue.QUOTING_FLAGS
+        )
+
+        self.__datetime_formatter = datetime_formatter
+        self.__datetime_format_str = datetime_format_str
+        self.__float_type = float_type
+        self.__strict_level_map = strict_level_map
+
+    def convert(self, dp_value: DataProperty) -> DataProperty:
+        try:
+            return self.__create_dataproperty(self.__convert_value(dp_value))
+        except TypeConversionError:
+            pass
+
+        if not self.__quoting_flags.get(dp_value.typecode):
+            if self.__preprocessor.is_escape_html_tag:
+                return self.__create_dataproperty(dp_value.to_str())
+
+            return dp_value
+
+        return self.__create_dataproperty(self.__apply_quote(dp_value.typecode, dp_value.to_str()))
+
+    def __create_dataproperty(self, value: Any) -> DataProperty:
+        return DataProperty(
+            value,
+            preprocessor=self.__preprocessor,
+            float_type=self.__float_type,
+            datetime_format_str=self.__datetime_format_str,
+            strict_level_map=MAX_STRICT_LEVEL_MAP,
+        )
+
+    def __apply_quote(self, typecode: Typecode, data: Any) -> Any:
+        if not self.__quoting_flags.get(typecode):
+            return data
+
+        try:
+            if self.__RE_QUOTE_LINE.search(data):
+                return data
+        except TypeError:
+            return data
+
+        return '"{}"'.format(self.__RE_QUOTE_CHAR.sub('\\"', data.replace("\\", "\\\\")))
+
+    def __convert_value(self, dp_value: DataProperty) -> Any:
+        if dp_value.typecode in self.__type_value_map:
+            return self.__apply_quote(dp_value.typecode, self.__type_value_map[dp_value.typecode])
+
+        if dp_value.typecode == Typecode.DATETIME and self.__datetime_formatter:
+            try:
+                return self.__apply_quote(
+                    dp_value.typecode, self.__datetime_formatter(dp_value.data)
+                )
+            except TypeError:
+                raise TypeConversionError
+
+        raise TypeConversionError("no need to convert")

llmeval-env/lib/python3.10/site-packages/dataproperty/_dataproperty.py

@@ -0,0 +1,382 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+import typing
+from decimal import Decimal
+from typing import Any, Optional, cast
+
+import typepy
+from mbstrdecoder import MultiByteStrDecoder
+from typepy import (
+    Bool,
+    DateTime,
+    Dictionary,
+    Infinity,
+    Integer,
+    IpAddress,
+    Nan,
+    NoneType,
+    NullString,
+    RealNumber,
+    StrictLevel,
+    String,
+    Typecode,
+    TypeConversionError,
+)
+from typepy.type import AbstractType
+
+from ._align import Align
+from ._align_getter import align_getter
+from ._base import DataPeropertyBase
+from ._common import DefaultValue
+from ._function import calc_ascii_char_width, get_number_of_digit
+from ._preprocessor import Preprocessor
+from .typing import FloatType, StrictLevelMap, TypeHint
+
+
+class DataProperty(DataPeropertyBase):
+    __slots__ = (
+        "__data",
+        "__no_ansi_escape_data",
+        "__align",
+        "__integer_digits",
+        "__additional_format_len",
+        "__length",
+        "__ascii_char_width",
+    )
+
+    __type_class_list: typing.List[AbstractType] = [
+        NoneType,
+        Integer,
+        Infinity,
+        Nan,
+        IpAddress,
+        RealNumber,
+        Bool,
+        typepy.List,
+        Dictionary,
+        DateTime,
+        NullString,
+        String,
+    ]
+
+    def __init__(
+        self,
+        data: Any,
+        preprocessor: Optional[Preprocessor] = None,
+        type_hint: TypeHint = None,
+        float_type: Optional[FloatType] = None,
+        format_flags: Optional[int] = None,
+        datetime_format_str: str = DefaultValue.DATETIME_FORMAT,
+        strict_level_map: Optional[StrictLevelMap] = None,
+        east_asian_ambiguous_width: int = 1,
+    ) -> None:
+        super().__init__(
+            format_flags=format_flags,
+            is_formatting_float=True,
+            datetime_format_str=datetime_format_str,
+            east_asian_ambiguous_width=east_asian_ambiguous_width,
+        )
+
+        self.__additional_format_len: Optional[int] = None
+        self.__align: Optional[Align] = None
+        self.__ascii_char_width: Optional[int] = None
+        self.__integer_digits: Optional[int] = None
+        self.__length: Optional[int] = None
+
+        if preprocessor is None:
+            preprocessor = Preprocessor()
+
+        data, no_ansi_escape_data = preprocessor.preprocess(data)
+
+        self.__set_data(data, type_hint, float_type, strict_level_map)
+
+        if no_ansi_escape_data is None or len(data) == len(no_ansi_escape_data):
+            self.__no_ansi_escape_data: Optional[DataProperty] = None
+        else:
+            self.__no_ansi_escape_data = DataProperty(no_ansi_escape_data, float_type=float_type)
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, DataProperty):
+            return False
+
+        if self.typecode != other.typecode:
+            return False
+
+        if self.typecode == Typecode.NAN:
+            return True
+
+        return self.data == other.data
+
+    def __ne__(self, other: Any) -> bool:
+        if not isinstance(other, DataProperty):
+            return True
+
+        if self.typecode != other.typecode:
+            return True
+
+        if self.typecode == Typecode.NAN:
+            return False
+
+        return self.data != other.data
+
+    def __repr__(self) -> str:
+        element_list = []
+
+        if self.typecode == Typecode.DATETIME:
+            element_list.append(f"data={str(self.data):s}")
+        else:
+            try:
+                element_list.append("data=" + self.to_str())
+            except UnicodeEncodeError:
+                element_list.append(f"data={MultiByteStrDecoder(self.data).unicode_str}")
+
+        element_list.extend(
+            [
+                f"type={self.typename:s}",
+                f"align={self.align.align_string}",
+                f"ascii_width={self.ascii_char_width:d}",
+            ]
+        )
+
+        if Integer(self.length).is_type():
+            element_list.append(f"length={self.length}")
+
+        if Integer(self.integer_digits).is_type():
+            element_list.append(f"int_digits={self.integer_digits}")
+
+        if Integer(self.decimal_places).is_type():
+            element_list.append(f"decimal_places={self.decimal_places}")
+
+        if Integer(self.additional_format_len).is_type():
+            element_list.append(f"extra_len={self.additional_format_len}")
+
+        return ", ".join(element_list)
+
+    @property
+    def align(self) -> Align:
+        if not self.__align:
+            if self.is_include_ansi_escape:
+                assert self.no_ansi_escape_dp
+                self.__align = self.no_ansi_escape_dp.align
+            else:
+                self.__align = align_getter.get_align_from_typecode(self.typecode)
+
+        assert self.__align
+
+        return self.__align
+
+    @property
+    def decimal_places(self) -> Optional[int]:
+        """
+        :return:
+            Decimal places if the ``data`` type either ``float`` or
+            ``decimal.Decimal``. Returns ``0`` if the ``data`` type is ``int``.
+            Otherwise, returns ``float("nan")``.
+        :rtype: int
+        """
+
+        if self._decimal_places is None:
+            self.__set_digit()
+
+        return self._decimal_places
+
+    @property
+    def data(self) -> Any:
+        """
+        :return: Original data value.
+        :rtype: Original data type.
+        """
+
+        return self.__data
+
+    @property
+    def is_include_ansi_escape(self) -> bool:
+        if self.no_ansi_escape_dp is None:
+            return False
+
+        return self.length != self.no_ansi_escape_dp.length
+
+    @property
+    def no_ansi_escape_dp(self) -> Optional["DataProperty"]:
+        return self.__no_ansi_escape_data
+
+    @property
+    def length(self) -> Optional[int]:
+        """
+        :return: Length of the ``data``.
+        :rtype: int
+        """
+
+        if self.__length is None:
+            self.__length = self.__get_length()
+
+        return self.__length
+
+    @property
+    def ascii_char_width(self) -> int:
+        if self.__ascii_char_width is None:
+            self.__ascii_char_width = self.__calc_ascii_char_width()
+
+        return self.__ascii_char_width
+
+    @property
+    def integer_digits(self) -> Optional[int]:
+        """
+        :return:
+            Integer digits if the ``data`` type either
+            ``int``/``float``/``decimal.Decimal``.
+            Otherwise, returns ``None``.
+        :rtype: int
+        """
+
+        if self.__integer_digits is None:
+            self.__set_digit()
+
+        return self.__integer_digits
+
+    @property
+    def additional_format_len(self) -> int:
+        if self.__additional_format_len is None:
+            self.__additional_format_len = self.__get_additional_format_len()
+
+        return self.__additional_format_len
+
+    def get_padding_len(self, ascii_char_width: int) -> int:
+        if self.typecode in (Typecode.LIST, Typecode.DICTIONARY):
+            unicode_str_len = DataProperty(MultiByteStrDecoder(str(self.data)).unicode_str).length
+            assert unicode_str_len
+            return max(
+                ascii_char_width - (self.ascii_char_width - unicode_str_len),
+                0,
+            )
+
+        try:
+            return max(ascii_char_width - (self.ascii_char_width - cast(int, self.length)), 0)
+        except TypeError:
+            return ascii_char_width
+
+    def to_str(self) -> str:
+        return self.format_str.format(self.data)
+
+    def __get_additional_format_len(self) -> int:
+        if not RealNumber(self.data, strip_ansi_escape=False).is_type():
+            return 0
+
+        format_len = 0
+
+        if Decimal(self.data) < 0:
+            # for minus character
+            format_len += 1
+
+        return format_len
+
+    def __get_base_float_len(self) -> int:
+        assert self.integer_digits is not None
+        assert self.decimal_places is not None
+
+        if any([self.integer_digits < 0, self.decimal_places < 0]):
+            raise ValueError("integer digits and decimal places must be greater or equals to zero")
+
+        float_len = self.integer_digits + self.decimal_places
+        if self.decimal_places > 0:
+            # for dot
+            float_len += 1
+
+        return float_len
+
+    def __get_length(self) -> Optional[int]:
+        if self.typecode in (Typecode.DICTIONARY, Typecode.LIST, Typecode.STRING):
+            return len(self.data)
+
+        return None
+
+    def __calc_ascii_char_width(self) -> int:
+        if self.typecode == Typecode.INTEGER:
+            return cast(int, self.integer_digits) + self.additional_format_len
+
+        if self.typecode == Typecode.REAL_NUMBER:
+            return self.__get_base_float_len() + self.additional_format_len
+
+        if self.typecode == Typecode.DATETIME:
+            try:
+                return len(self.to_str())
+            except ValueError:
+                # reach to this line if the year <1900.
+                # the datetime strftime() methods require year >= 1900.
+                return len(str(self.data))
+
+        if self.is_include_ansi_escape:
+            assert self.no_ansi_escape_dp
+            return self.no_ansi_escape_dp.ascii_char_width
+
+        try:
+            unicode_str = MultiByteStrDecoder(self.data).unicode_str
+        except ValueError:
+            unicode_str = self.to_str()
+
+        return calc_ascii_char_width(unicode_str, self._east_asian_ambiguous_width)
+
+    def __set_data(
+        self,
+        data: Any,
+        type_hint: TypeHint,
+        float_type: Optional[FloatType],
+        strict_level_map: Optional[StrictLevelMap],
+    ) -> None:
+        if float_type is None:
+            float_type = DefaultValue.FLOAT_TYPE
+
+        if strict_level_map is None:
+            strict_level_map = DefaultValue.STRICT_LEVEL_MAP
+
+        if type_hint:
+            type_obj = type_hint(
+                data, strict_level=StrictLevel.MIN, float_type=float_type, strip_ansi_escape=False
+            )
+            self._typecode = type_obj.typecode
+            self.__data = type_obj.try_convert()
+
+            if type_hint(
+                self.__data,
+                strict_level=StrictLevel.MAX,
+                float_type=float_type,
+                strip_ansi_escape=False,
+            ).is_type():
+                return
+
+        for type_class in self.__type_class_list:
+            strict_level = strict_level_map.get(
+                type_class(None).typecode, strict_level_map.get("default", StrictLevel.MAX)
+            )
+
+            if self.__try_convert_type(data, type_class, strict_level, float_type):
+                return
+
+        raise TypeConversionError(
+            f"failed to convert: data={data}, strict_level={strict_level_map}"
+        )
+
+    def __set_digit(self) -> None:
+        integer_digits, decimal_places = get_number_of_digit(self.__data)
+        self.__integer_digits = integer_digits
+        self._decimal_places = decimal_places
+
+    def __try_convert_type(
+        self,
+        data: Any,
+        type_class: AbstractType,
+        strict_level: int,
+        float_type: Optional[FloatType],
+    ) -> bool:
+        type_obj = type_class(data, strict_level, float_type=float_type, strip_ansi_escape=False)
+
+        try:
+            self.__data = type_obj.convert()
+        except TypeConversionError:
+            return False
+
+        self._typecode = type_obj.typecode
+
+        return True

llmeval-env/lib/python3.10/site-packages/dataproperty/_extractor.py

@@ -0,0 +1,814 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+import copy
+import enum
+import sys
+import typing
+from collections import Counter
+from decimal import Decimal
+from typing import Any, Dict, List, Mapping, Optional, Sequence, Tuple, Type, Union, cast
+
+import typepy
+from typepy import (
+    Bool,
+    DateTime,
+    Dictionary,
+    Infinity,
+    Integer,
+    IpAddress,
+    Nan,
+    NoneType,
+    NullString,
+    RealNumber,
+    StrictLevel,
+    String,
+    Typecode,
+    is_empty_sequence,
+)
+from typepy.type import AbstractType
+
+from ._column import ColumnDataProperty
+from ._common import MIN_STRICT_LEVEL_MAP, DefaultValue
+from ._converter import DataPropertyConverter
+from ._dataproperty import DataProperty
+from ._formatter import Format
+from ._preprocessor import Preprocessor
+from .logger import logger
+from .typing import (
+    DateTimeFormatter,
+    StrictLevelMap,
+    TransFunc,
+    TypeHint,
+    TypeValueMap,
+    normalize_type_hint,
+)
+
+
+DataPropertyMatrix = List[List[DataProperty]]
+
+
+@enum.unique
+class MatrixFormatting(enum.Enum):
+    # raise exception if the matrix is not properly formatted
+    EXCEPTION = 1 << 1
+
+    # trim to the minimum size column
+    TRIM = 1 << 2
+
+    # Append None values to columns so that it is the same as the maximum
+    # column size.
+    FILL_NONE = 1 << 3
+
+    HEADER_ALIGNED = 1 << 4
+
+
+class DataPropertyExtractor:
+    """
+    .. py:attribute:: quoting_flags
+
+        Configurations to add double quote to for each items in a matrix,
+        where |Typecode| of table-value is |True| in the ``quote_flag_table``
+        mapping table. ``quote_flag_table`` should be a dictionary.
+        And is ``{ Typecode : bool }``. Defaults to:
+
+        .. code-block:: json
+            :caption: The default values
+
+            {
+                Typecode.BOOL: False,
+                Typecode.DATETIME: False,
+                Typecode.DICTIONARY: False,
+                Typecode.INFINITY: False,
+                Typecode.INTEGER: False,
+                Typecode.IP_ADDRESS: False,
+                Typecode.LIST: False,
+                Typecode.NAN: False,
+                Typecode.NULL_STRING: False,
+                Typecode.NONE: False,
+                Typecode.REAL_NUMBER: False,
+                Typecode.STRING: False,
+            }
+    """
+
+    def __init__(self, max_precision: Optional[int] = None) -> None:
+        self.max_workers = DefaultValue.MAX_WORKERS
+
+        if max_precision is None:
+            self.__max_precision = DefaultValue.MAX_PRECISION
+        else:
+            self.__max_precision = max_precision
+
+        self.__headers: Sequence[str] = []
+        self.__default_type_hint: TypeHint = None
+        self.__col_type_hints: List[TypeHint] = []
+
+        self.__strip_str_header: Optional[str] = None
+        self.__is_formatting_float = True
+        self.__min_col_ascii_char_width = 0
+        self.__default_format_flags = Format.NONE
+        self.__format_flags_list: Sequence[int] = []
+        self.__float_type: Union[Type[float], Type[Decimal], None] = None
+        self.__datetime_format_str = DefaultValue.DATETIME_FORMAT
+        self.__strict_level_map = copy.deepcopy(
+            cast(Dict[Union[Typecode, str], int], DefaultValue.STRICT_LEVEL_MAP)
+        )
+        self.__east_asian_ambiguous_width = 1
+
+        self.__preprocessor = Preprocessor()
+
+        self.__type_value_map: Mapping[Typecode, Union[float, Decimal, None]] = copy.deepcopy(
+            DefaultValue.TYPE_VALUE_MAP
+        )
+
+        self.__trans_func_list: List[TransFunc] = []
+        self.__quoting_flags = copy.deepcopy(DefaultValue.QUOTING_FLAGS)
+        self.__datetime_formatter: Optional[DateTimeFormatter] = None
+        self.__matrix_formatting = MatrixFormatting.TRIM
+        self.__dp_converter: DataPropertyConverter
+
+        self.__clear_cache()
+
+    def __clear_cache(self) -> None:
+        self.__update_dp_converter()
+        self.__dp_cache_zero = self.__to_dp_raw(0)
+        self.__dp_cache_one = self.__to_dp_raw(1)
+        self.__dp_cache_true = self.__to_dp_raw(True)
+        self.__dp_cache_false = self.__to_dp_raw(False)
+        self.__dp_cache_map = {None: self.__to_dp_raw(None), "": self.__to_dp_raw("")}
+
+    @property
+    def headers(self) -> Sequence[str]:
+        return self.__headers
+
+    @headers.setter
+    def headers(self, value: Sequence[str]) -> None:
+        if self.__headers == value:
+            return
+
+        self.__headers = value
+        self.__clear_cache()
+
+    @property
+    def default_type_hint(self) -> TypeHint:
+        return self.__default_type_hint
+
+    @default_type_hint.setter
+    def default_type_hint(self, value: TypeHint) -> None:
+        if self.__default_type_hint == value:
+            return
+
+        self.__default_type_hint = value
+        self.__clear_cache()
+
+    @property
+    def column_type_hints(self) -> List[TypeHint]:
+        return self.__col_type_hints
+
+    @column_type_hints.setter
+    def column_type_hints(self, value: Sequence[Union[str, TypeHint]]) -> None:
+        normalized_type_hints: List[TypeHint] = []
+
+        for type_hint in value:
+            type_hint = normalize_type_hint(type_hint)
+            if type_hint not in (
+                Bool,
+                DateTime,
+                Dictionary,
+                Infinity,
+                Integer,
+                IpAddress,
+                typepy.List,
+                Nan,
+                NoneType,
+                RealNumber,
+                String,
+                NullString,
+                None,
+            ):
+                raise ValueError(f"invalid type hint: {type(type_hint)}")
+
+            normalized_type_hints.append(type_hint)
+
+        if self.__col_type_hints == normalized_type_hints:
+            return
+
+        self.__col_type_hints = normalized_type_hints
+        self.__clear_cache()
+
+    @property
+    def is_formatting_float(self) -> bool:
+        return self.__is_formatting_float
+
+    @is_formatting_float.setter
+    def is_formatting_float(self, value: bool) -> None:
+        self.__is_formatting_float = value
+
+    @property
+    def max_precision(self) -> int:
+        return self.__max_precision
+
+    @max_precision.setter
+    def max_precision(self, value: int) -> None:
+        if self.__max_precision == value:
+            return
+
+        self.__max_precision = value
+        self.__clear_cache()
+
+    @property
+    def preprocessor(self) -> Preprocessor:
+        return self.__preprocessor
+
+    @preprocessor.setter
+    def preprocessor(self, value: Preprocessor) -> None:
+        if self.preprocessor == value:
+            return
+
+        self.__preprocessor = value
+        self.__update_dp_converter()
+
+    @property
+    def strip_str_header(self) -> Optional[str]:
+        return self.__strip_str_header
+
+    @strip_str_header.setter
+    def strip_str_header(self, value: str) -> None:
+        if self.__strip_str_header == value:
+            return
+
+        self.__strip_str_header = value
+        self.__clear_cache()
+
+    @property
+    def min_column_width(self) -> int:
+        return self.__min_col_ascii_char_width
+
+    @min_column_width.setter
+    def min_column_width(self, value: int) -> None:
+        if self.__min_col_ascii_char_width == value:
+            return
+
+        self.__min_col_ascii_char_width = value
+        self.__clear_cache()
+
+    @property
+    def default_format_flags(self) -> int:
+        return self.__default_format_flags
+
+    @default_format_flags.setter
+    def default_format_flags(self, value: int) -> None:
+        if self.__default_format_flags == value:
+            return
+
+        self.__default_format_flags = value
+        self.__clear_cache()
+
+    @property
+    def format_flags_list(self) -> Sequence[int]:
+        return self.__format_flags_list
+
+    @format_flags_list.setter
+    def format_flags_list(self, value: Sequence[int]) -> None:
+        if self.__format_flags_list == value:
+            return
+
+        self.__format_flags_list = value
+        self.__clear_cache()
+
+    @property
+    def float_type(self) -> Union[Type[float], Type[Decimal], None]:
+        return self.__float_type
+
+    @float_type.setter
+    def float_type(self, value: Union[Type[float], Type[Decimal]]) -> None:
+        if self.__float_type == value:
+            return
+
+        self.__float_type = value
+        self.__clear_cache()
+
+    @property
+    def datetime_format_str(self) -> str:
+        return self.__datetime_format_str
+
+    @datetime_format_str.setter
+    def datetime_format_str(self, value: str) -> None:
+        if self.__datetime_format_str == value:
+            return
+
+        self.__datetime_format_str = value
+        self.__clear_cache()
+
+    @property
+    def strict_level_map(self) -> StrictLevelMap:
+        return self.__strict_level_map
+
+    @strict_level_map.setter
+    def strict_level_map(self, value: StrictLevelMap) -> None:
+        if self.__strict_level_map == value:
+            return
+
+        self.__strict_level_map = cast(Dict[Union[Typecode, str], int], value)
+        self.__clear_cache()
+
+    @property
+    def east_asian_ambiguous_width(self) -> int:
+        return self.__east_asian_ambiguous_width
+
+    @east_asian_ambiguous_width.setter
+    def east_asian_ambiguous_width(self, value: int) -> None:
+        if self.__east_asian_ambiguous_width == value:
+            return
+
+        self.__east_asian_ambiguous_width = value
+        self.__clear_cache()
+
+    @property
+    def type_value_map(self) -> TypeValueMap:
+        return self.__type_value_map
+
+    @type_value_map.setter
+    def type_value_map(self, value: TypeValueMap) -> None:
+        if self.__type_value_map == value:
+            return
+
+        self.__type_value_map = value
+        self.__clear_cache()
+
+    def register_trans_func(self, trans_func: TransFunc) -> None:
+        self.__trans_func_list.insert(0, trans_func)
+        self.__clear_cache()
+
+    @property
+    def quoting_flags(self) -> Dict[Typecode, bool]:
+        return self.__quoting_flags
+
+    @quoting_flags.setter
+    def quoting_flags(self, value: Dict[Typecode, bool]) -> None:
+        if self.__quoting_flags == value:
+            return
+
+        self.__quoting_flags = value
+        self.__clear_cache()
+
+    @property
+    def datetime_formatter(self) -> Optional[DateTimeFormatter]:
+        return self.__datetime_formatter
+
+    @datetime_formatter.setter
+    def datetime_formatter(self, value: Optional[DateTimeFormatter]) -> None:
+        if self.__datetime_formatter == value:
+            return
+
+        self.__datetime_formatter = value
+        self.__clear_cache()
+
+    @property
+    def matrix_formatting(self) -> MatrixFormatting:
+        return self.__matrix_formatting
+
+    @matrix_formatting.setter
+    def matrix_formatting(self, value: MatrixFormatting) -> None:
+        if self.__matrix_formatting == value:
+            return
+
+        self.__matrix_formatting = value
+        self.__clear_cache()
+
+    @property
+    def max_workers(self) -> int:
+        assert self.__max_workers
+
+        return self.__max_workers
+
+    @max_workers.setter
+    def max_workers(self, value: Optional[int]) -> None:
+        try:
+            from _multiprocessing import SemLock, sem_unlink  # noqa
+        except ImportError:
+            logger.debug("This platform lacks a functioning sem_open implementation")
+            value = 1
+
+        if "pytest" in sys.modules and value != 1:
+            logger.debug("set max_workers to 1 to avoid deadlock when executed from pytest")
+            value = 1
+
+        self.__max_workers = value
+        if not self.__max_workers:
+            self.__max_workers = DefaultValue.MAX_WORKERS
+
+    def to_dp(self, value: Any) -> DataProperty:
+        self.__update_dp_converter()
+
+        return self.__to_dp(value)
+
+    def to_dp_list(self, values: Sequence[Any]) -> List[DataProperty]:
+        if is_empty_sequence(values):
+            return []
+
+        self.__update_dp_converter()
+
+        return self._to_dp_list(values)
+
+    def to_column_dp_list(
+        self,
+        value_dp_matrix: Any,
+        previous_column_dp_list: Optional[Sequence[ColumnDataProperty]] = None,
+    ) -> List[ColumnDataProperty]:
+        col_dp_list = self.__get_col_dp_list_base()
+
+        logger.debug("converting to column dataproperty:")
+
+        logs = ["  params:"]
+        if self.headers:
+            logs.append(f"    headers={len(self.headers)}")
+        logs.extend(
+            [
+                "    prev_col_count={}".format(
+                    len(previous_column_dp_list) if previous_column_dp_list else None
+                ),
+                f"    matrix_formatting={self.matrix_formatting}",
+            ]
+        )
+        if self.column_type_hints:
+            logs.append(
+                "    column_type_hints=({})".format(
+                    ", ".join(
+                        [
+                            type_hint.__name__ if type_hint else "none"
+                            for type_hint in self.column_type_hints
+                        ]
+                    )
+                )
+            )
+        else:
+            logs.append("    column_type_hints=()")
+
+        for log in logs:
+            logger.debug(log)
+
+        logger.debug("  results:")
+        for col_idx, value_dp_list in enumerate(zip(*value_dp_matrix)):
+            try:
+                col_dp_list[col_idx]
+            except IndexError:
+                col_dp_list.append(
+                    ColumnDataProperty(
+                        column_index=col_idx,
+                        float_type=self.float_type,
+                        min_width=self.min_column_width,
+                        format_flags=self.__get_format_flags(col_idx),
+                        is_formatting_float=self.is_formatting_float,
+                        datetime_format_str=self.datetime_format_str,
+                        east_asian_ambiguous_width=self.east_asian_ambiguous_width,
+                        max_precision=self.__max_precision,
+                    )
+                )
+
+            col_dp = col_dp_list[col_idx]
+            col_dp.begin_update()
+
+            try:
+                col_dp.merge(previous_column_dp_list[col_idx])  # type: ignore
+            except (TypeError, IndexError):
+                pass
+
+            for value_dp in value_dp_list:
+                col_dp.update_body(value_dp)
+
+            col_dp.end_update()
+
+            logger.debug(f"    {str(col_dp):s}")
+
+        return col_dp_list
+
+    def to_dp_matrix(self, value_matrix: Sequence[Sequence[Any]]) -> DataPropertyMatrix:
+        self.__update_dp_converter()
+        logger.debug(f"max_workers={self.max_workers}, preprocessor={self.__preprocessor}")
+
+        value_matrix = self.__strip_data_matrix(value_matrix)
+
+        if self.__is_dp_matrix(value_matrix):
+            logger.debug("already a dataproperty matrix")
+            return value_matrix  # type: ignore
+
+        if self.max_workers <= 1:
+            return self.__to_dp_matrix_st(value_matrix)
+
+        return self.__to_dp_matrix_mt(value_matrix)
+
+    def to_header_dp_list(self) -> List[DataProperty]:
+        self.__update_dp_converter()
+
+        preprocessor = copy.deepcopy(self.__preprocessor)
+        preprocessor.strip_str = self.strip_str_header
+
+        return self._to_dp_list(
+            self.headers,
+            type_hint=String,
+            preprocessor=preprocessor,
+            strict_level_map=MIN_STRICT_LEVEL_MAP,
+        )
+
+    def update_preprocessor(self, **kwargs: Any) -> bool:
+        is_updated = self.__preprocessor.update(**kwargs)
+        self.__update_dp_converter()
+
+        return is_updated
+
+    def update_strict_level_map(self, value: StrictLevelMap) -> bool:
+        org = copy.deepcopy(self.__strict_level_map)
+        self.__strict_level_map.update(value)
+
+        if org == self.__strict_level_map:
+            return False
+
+        self.__clear_cache()
+
+        return True
+
+    """
+    def update_dict(self, lhs: Mapping, rhs: Mapping) -> bool:
+        is_updated = False
+
+        for key, value in rhs.items():
+            if key not in lhs:
+                lhs[]
+                continue
+
+            if getattr(lhs, key) == value:
+                continue
+
+            setattr(lhs, key, value)
+            is_updated = True
+
+        return is_updated
+    """
+
+    @staticmethod
+    def __is_dp_matrix(value: Any) -> bool:
+        try:
+            return isinstance(value[0][0], DataProperty)
+        except (TypeError, IndexError):
+            return False
+
+    def __get_col_type_hint(self, col_idx: int) -> TypeHint:
+        try:
+            return self.column_type_hints[col_idx]
+        except (TypeError, IndexError):
+            return self.default_type_hint
+
+    def __get_format_flags(self, col_idx: int) -> int:
+        try:
+            return self.format_flags_list[col_idx]
+        except (TypeError, IndexError):
+            return self.__default_format_flags
+
+    def __to_dp(
+        self,
+        data: Any,
+        type_hint: TypeHint = None,
+        preprocessor: Optional[Preprocessor] = None,
+        strict_level_map: Optional[StrictLevelMap] = None,
+    ) -> DataProperty:
+        for trans_func in self.__trans_func_list:
+            data = trans_func(data)
+
+        if type_hint:
+            return self.__to_dp_raw(
+                data,
+                type_hint=type_hint,
+                preprocessor=preprocessor,
+                strict_level_map=strict_level_map,
+            )
+
+        try:
+            if data in self.__dp_cache_map:
+                return self.__dp_cache_map[data]
+        except TypeError:
+            # unhashable type
+            pass
+
+        if data == 0:
+            if data is False:
+                return self.__dp_cache_false
+            return self.__dp_cache_zero
+        if data == 1:
+            if data is True:
+                return self.__dp_cache_true
+            return self.__dp_cache_one
+
+        return self.__to_dp_raw(
+            data, type_hint=type_hint, preprocessor=preprocessor, strict_level_map=strict_level_map
+        )
+
+    def __to_dp_raw(
+        self,
+        data: Any,
+        type_hint: TypeHint = None,
+        preprocessor: Optional[Preprocessor] = None,
+        strict_level_map: Optional[StrictLevelMap] = None,
+    ) -> DataProperty:
+        if preprocessor:
+            preprocessor = Preprocessor(
+                dequote=preprocessor.dequote,
+                line_break_handling=preprocessor.line_break_handling,
+                line_break_repl=preprocessor.line_break_repl,
+                strip_str=preprocessor.strip_str,
+                is_escape_formula_injection=preprocessor.is_escape_formula_injection,
+            )
+        else:
+            preprocessor = Preprocessor(
+                dequote=self.preprocessor.dequote,
+                line_break_handling=self.preprocessor.line_break_handling,
+                line_break_repl=self.preprocessor.line_break_repl,
+                strip_str=self.preprocessor.strip_str,
+                is_escape_formula_injection=self.__preprocessor.is_escape_formula_injection,
+            )
+
+        value_dp = DataProperty(
+            data,
+            preprocessor=preprocessor,
+            type_hint=(type_hint if type_hint is not None else self.default_type_hint),
+            float_type=self.float_type,
+            datetime_format_str=self.datetime_format_str,
+            strict_level_map=(strict_level_map if type_hint is not None else self.strict_level_map),
+            east_asian_ambiguous_width=self.east_asian_ambiguous_width,
+        )
+
+        return self.__dp_converter.convert(value_dp)
+
+    def __to_dp_matrix_st(self, value_matrix: Sequence[Sequence[Any]]) -> DataPropertyMatrix:
+        return list(
+            zip(  # type: ignore
+                *(
+                    _to_dp_list_helper(
+                        self,
+                        col_idx,
+                        values,
+                        self.__get_col_type_hint(col_idx),
+                        self.__preprocessor,
+                    )[1]
+                    for col_idx, values in enumerate(zip(*value_matrix))
+                )
+            )
+        )
+
+    def __to_dp_matrix_mt(self, value_matrix: Sequence[Sequence[Any]]) -> DataPropertyMatrix:
+        from concurrent import futures
+
+        col_data_map = {}
+
+        with futures.ProcessPoolExecutor(self.max_workers) as executor:
+            future_list = [
+                executor.submit(
+                    _to_dp_list_helper,
+                    self,
+                    col_idx,
+                    values,
+                    self.__get_col_type_hint(col_idx),
+                    self.__preprocessor,
+                )
+                for col_idx, values in enumerate(zip(*value_matrix))
+            ]
+
+            for future in futures.as_completed(future_list):
+                col_idx, value_dp_list = future.result()
+                col_data_map[col_idx] = value_dp_list
+
+        return list(
+            zip(*(col_data_map[col_idx] for col_idx in sorted(col_data_map)))  # type: ignore
+        )
+
+    def _to_dp_list(
+        self,
+        data_list: Sequence[Any],
+        type_hint: TypeHint = None,
+        preprocessor: Optional[Preprocessor] = None,
+        strict_level_map: Optional[StrictLevelMap] = None,
+    ) -> List[DataProperty]:
+        if is_empty_sequence(data_list):
+            return []
+
+        type_counter: typing.Counter[Type[AbstractType]] = Counter()
+
+        dp_list = []
+        for data in data_list:
+            expect_type_hint: TypeHint = type_hint
+            if type_hint is None:
+                try:
+                    expect_type_hint, _count = type_counter.most_common(1)[0]
+                    if not expect_type_hint(
+                        data, float_type=self.float_type, strict_level=StrictLevel.MAX
+                    ).is_type():
+                        expect_type_hint = None
+                except IndexError:
+                    pass
+
+            dataprop = self.__to_dp(
+                data=data,
+                type_hint=expect_type_hint,
+                preprocessor=preprocessor if preprocessor else self.__preprocessor,
+                strict_level_map=strict_level_map,
+            )
+            type_counter[dataprop.type_class] += 1
+
+            dp_list.append(dataprop)
+
+        return dp_list
+
+    def __strip_data_matrix(self, data_matrix: Sequence[Sequence[Any]]) -> Sequence[Sequence[Any]]:
+        header_col_size = len(self.headers) if self.headers else 0
+        try:
+            col_size_list = [len(data_list) for data_list in data_matrix]
+        except TypeError:
+            return []
+
+        if self.headers:
+            min_col_size = min([header_col_size] + col_size_list)
+            max_col_size = max([header_col_size] + col_size_list)
+        elif col_size_list:
+            min_col_size = min(col_size_list)
+            max_col_size = max(col_size_list)
+        else:
+            min_col_size = 0
+            max_col_size = 0
+
+        if self.matrix_formatting == MatrixFormatting.EXCEPTION:
+            if min_col_size != max_col_size:
+                raise ValueError(
+                    "nonuniform column size found: min={}, max={}".format(
+                        min_col_size, max_col_size
+                    )
+                )
+
+            return data_matrix
+
+        if self.matrix_formatting == MatrixFormatting.HEADER_ALIGNED:
+            if header_col_size > 0:
+                format_col_size = header_col_size
+            else:
+                format_col_size = max_col_size
+        elif self.matrix_formatting == MatrixFormatting.TRIM:
+            format_col_size = min_col_size
+        elif self.matrix_formatting == MatrixFormatting.FILL_NONE:
+            format_col_size = max_col_size
+        else:
+            raise ValueError(f"unknown matrix formatting: {self.matrix_formatting}")
+
+        return [
+            list(data_matrix[row_idx][:format_col_size]) + [None] * (format_col_size - col_size)
+            for row_idx, col_size in enumerate(col_size_list)
+        ]
+
+    def __get_col_dp_list_base(self) -> List[ColumnDataProperty]:
+        header_dp_list = self.to_header_dp_list()
+        col_dp_list = []
+
+        for col_idx, header_dp in enumerate(header_dp_list):
+            col_dp = ColumnDataProperty(
+                column_index=col_idx,
+                float_type=self.float_type,
+                min_width=self.min_column_width,
+                format_flags=self.__get_format_flags(col_idx),
+                is_formatting_float=self.is_formatting_float,
+                datetime_format_str=self.datetime_format_str,
+                east_asian_ambiguous_width=self.east_asian_ambiguous_width,
+                max_precision=self.__max_precision,
+            )
+            col_dp.update_header(header_dp)
+            col_dp_list.append(col_dp)
+
+        return col_dp_list
+
+    def __update_dp_converter(self) -> None:
+        preprocessor = Preprocessor(
+            line_break_handling=self.__preprocessor.line_break_handling,
+            line_break_repl=self.preprocessor.line_break_repl,
+            is_escape_html_tag=self.__preprocessor.is_escape_html_tag,
+            is_escape_formula_injection=self.__preprocessor.is_escape_formula_injection,
+        )
+        self.__dp_converter = DataPropertyConverter(
+            preprocessor=preprocessor,
+            type_value_map=self.type_value_map,
+            quoting_flags=self.quoting_flags,
+            datetime_formatter=self.datetime_formatter,
+            datetime_format_str=self.datetime_format_str,
+            float_type=self.float_type,
+            strict_level_map=self.strict_level_map,
+        )
+
+
+def _to_dp_list_helper(
+    extractor: DataPropertyExtractor,
+    col_idx: int,
+    data_list: Sequence[Any],
+    type_hint: TypeHint,
+    preprocessor: Preprocessor,
+) -> Tuple[int, List[DataProperty]]:
+    return (
+        col_idx,
+        extractor._to_dp_list(data_list, type_hint=type_hint, preprocessor=preprocessor),
+    )

llmeval-env/lib/python3.10/site-packages/dataproperty/_formatter.py

@@ -0,0 +1,98 @@
+import copy
+from decimal import Decimal
+from typing import Dict, Optional, Union
+
+from typepy import Nan, Typecode
+
+
+DecimalPlaces = Union[float, Decimal]
+
+
+class Format:
+    NONE = 0
+    THOUSAND_SEPARATOR = 1
+
+
+class Formatter:
+    __slots__ = ("__is_formatting_float", "__format_flags", "__datetime_format_str")
+
+    _BLANK_CURLY_BRACES_FORMAT_MAP: Dict[Typecode, str] = {
+        Typecode.NONE: "{}",
+        Typecode.IP_ADDRESS: "{}",
+        Typecode.BOOL: "{}",
+        Typecode.DICTIONARY: "{}",
+        Typecode.LIST: "{}",
+    }
+
+    def __init__(
+        self,
+        datetime_format_str: str,
+        is_formatting_float: Optional[bool] = True,
+        format_flags: Optional[int] = None,
+    ) -> None:
+        if format_flags is not None:
+            self.__format_flags = format_flags
+        else:
+            self.__format_flags = Format.NONE
+
+        self.__datetime_format_str = datetime_format_str
+        self.__is_formatting_float = is_formatting_float
+
+    def make_format_map(
+        self, decimal_places: Optional[DecimalPlaces] = None
+    ) -> Dict[Typecode, str]:
+        format_map = copy.copy(self._BLANK_CURLY_BRACES_FORMAT_MAP)
+        format_map.update(
+            {
+                Typecode.INTEGER: self.make_format_str(Typecode.INTEGER),
+                Typecode.REAL_NUMBER: self.make_format_str(Typecode.REAL_NUMBER, decimal_places),
+                Typecode.INFINITY: self.make_format_str(Typecode.INFINITY),
+                Typecode.NAN: self.make_format_str(Typecode.NAN),
+                Typecode.DATETIME: self.make_format_str(Typecode.DATETIME),
+            }
+        )
+
+        return format_map
+
+    def make_format_str(
+        self, typecode: Typecode, decimal_places: Optional[DecimalPlaces] = None
+    ) -> str:
+        format_str = self._BLANK_CURLY_BRACES_FORMAT_MAP.get(typecode)
+        if format_str is not None:
+            return format_str
+
+        if typecode == Typecode.INTEGER:
+            return self.__get_integer_format()
+
+        if typecode in (Typecode.REAL_NUMBER, Typecode.INFINITY, Typecode.NAN):
+            return self.__get_realnumber_format(decimal_places)
+
+        if typecode == Typecode.DATETIME:
+            return "{:" + self.__datetime_format_str + "}"
+
+        return "{:s}"
+
+    def __get_base_format_str(self) -> str:
+        if self.__format_flags & Format.THOUSAND_SEPARATOR:
+            return ","
+
+        return ""
+
+    def __get_integer_format(self) -> str:
+        return "{:" + self.__get_base_format_str() + "d}"
+
+    def __get_realnumber_format(self, decimal_places: Optional[DecimalPlaces]) -> str:
+        if not self.__is_formatting_float:
+            return "{}"
+
+        base_format = self.__get_base_format_str()
+
+        if decimal_places is None or Nan(decimal_places).is_type():
+            return "{:" + base_format + "f}"
+
+        try:
+            return "{:" + f"{base_format:s}.{decimal_places:d}f" + "}"
+        except ValueError:
+            pass
+
+        return "{:" + base_format + "f}"

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

@@ -0,0 +1,112 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+import decimal
+import re
+from decimal import Decimal
+from typing import Any, Optional, Tuple, Union
+
+from typepy import Integer, RealNumber, TypeConversionError
+
+
+decimal.setcontext(decimal.Context(prec=60, rounding=decimal.ROUND_HALF_DOWN))
+
+_ansi_escape = re.compile(r"(\x9b|\x1b\[)[0-?]*[ -\/]*[@-~]", re.IGNORECASE)
+
+
+def get_integer_digit(value: Any) -> int:
+    float_type = RealNumber(value)
+
+    try:
+        abs_value = abs(float_type.convert())
+    except TypeConversionError:
+        try:
+            abs_value = abs(Integer(value).convert())
+        except TypeConversionError:
+            raise ValueError(f"the value must be a number: value='{value}' type='{type(value)}'")
+
+        return len(str(abs_value))
+
+    if abs_value.is_zero():
+        return 1
+
+    try:
+        return len(str(abs_value.quantize(Decimal("1."), rounding=decimal.ROUND_DOWN)))
+    except decimal.InvalidOperation:
+        return len(str(abs_value))
+
+
+class DigitCalculator:
+    REGEXP_COMMON_LOG = re.compile(r"[\d\.]+[eE]\-\d+")
+    REGEXP_SPLIT = re.compile(r"[eE]\-")
+
+    def get_decimal_places(self, value: Union[str, float, int, Decimal]) -> int:
+        if Integer(value).is_type():
+            return 0
+
+        float_digit_len = 0
+        abs_value = abs(float(value))
+        text_value = str(abs_value)
+        float_text = "0"
+        if text_value.find(".") != -1:
+            float_text = text_value.split(".")[1]
+            float_digit_len = len(float_text)
+        elif self.REGEXP_COMMON_LOG.search(text_value):
+            float_text = self.REGEXP_SPLIT.split(text_value)[1]
+            float_digit_len = int(float_text)
+
+        return float_digit_len
+
+
+_digit_calculator = DigitCalculator()
+
+
+def get_number_of_digit(
+    value: Any, max_decimal_places: int = 99
+) -> Tuple[Optional[int], Optional[int]]:
+    try:
+        integer_digits = get_integer_digit(value)
+    except (ValueError, TypeError, OverflowError):
+        return (None, None)
+
+    try:
+        decimal_places: Optional[int] = min(
+            _digit_calculator.get_decimal_places(value), max_decimal_places
+        )
+    except (ValueError, TypeError):
+        decimal_places = None
+
+    return (integer_digits, decimal_places)
+
+
+def _validate_eaaw(east_asian_ambiguous_width: int) -> None:
+    if east_asian_ambiguous_width in (1, 2):
+        return
+
+    raise ValueError(
+        "invalid east_asian_ambiguous_width: expected=1 or 2, actual={}".format(
+            east_asian_ambiguous_width
+        )
+    )
+
+
+def strip_ansi_escape(unicode_str: str) -> str:
+    return _ansi_escape.sub("", unicode_str)
+
+
+def calc_ascii_char_width(unicode_str: str, east_asian_ambiguous_width: int = 1) -> int:
+    import unicodedata
+
+    width = 0
+    for char in unicode_str:
+        char_width = unicodedata.east_asian_width(char)
+        if char_width in "WF":
+            width += 2
+        elif char_width == "A":
+            _validate_eaaw(east_asian_ambiguous_width)
+            width += east_asian_ambiguous_width
+        else:
+            width += 1
+
+    return width

llmeval-env/lib/python3.10/site-packages/dataproperty/_interface.py

@@ -0,0 +1,30 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+import abc
+from typing import Optional
+
+from typepy import Typecode
+
+from ._align import Align
+
+
+class DataPeropertyInterface(metaclass=abc.ABCMeta):
+    __slots__ = ()
+
+    @abc.abstractproperty
+    def align(self) -> Align:  # pragma: no cover
+        pass
+
+    @abc.abstractproperty
+    def decimal_places(self) -> Optional[int]:  # pragma: no cover
+        pass
+
+    @abc.abstractproperty
+    def typecode(self) -> Typecode:  # pragma: no cover
+        pass
+
+    @abc.abstractproperty
+    def typename(self) -> str:  # pragma: no cover
+        pass

llmeval-env/lib/python3.10/site-packages/dataproperty/_line_break.py

@@ -0,0 +1,8 @@
+from enum import Enum, unique
+
+
+@unique
+class LineBreakHandling(Enum):
+    NOP = 0
+    REPLACE = 1
+    ESCAPE = 2

llmeval-env/lib/python3.10/site-packages/dataproperty/_preprocessor.py

@@ -0,0 +1,173 @@
+import html
+import re
+from typing import Any, Optional, Tuple, Union
+
+from mbstrdecoder import MultiByteStrDecoder
+
+from ._function import strip_ansi_escape
+from ._line_break import LineBreakHandling
+
+
+_RE_LINE_BREAK = re.compile(r"\r\n|\n")
+_RE_FORMULA_PREFIX = re.compile(r"^[-\+=@]")
+
+
+def normalize_lbh(value: Optional[LineBreakHandling]) -> LineBreakHandling:
+    if isinstance(value, LineBreakHandling):
+        return value
+
+    if value is None:
+        return LineBreakHandling.NOP
+
+    return LineBreakHandling[value.upper()]  # type: ignore
+
+
+class Preprocessor:
+    @property
+    def line_break_handling(self) -> Optional[LineBreakHandling]:
+        return self.__line_break_handling
+
+    @line_break_handling.setter
+    def line_break_handling(self, value: Optional[LineBreakHandling]) -> None:
+        self.__line_break_handling = normalize_lbh(value)
+
+    def __init__(
+        self,
+        strip_str: Optional[Union[str, bytes]] = None,
+        replace_tabs_with_spaces: bool = True,
+        tab_length: int = 2,
+        line_break_handling: Optional[LineBreakHandling] = None,
+        line_break_repl: str = " ",
+        dequote: bool = False,
+        is_escape_html_tag: bool = False,
+        is_escape_formula_injection: bool = False,
+    ) -> None:
+        self.strip_str = strip_str
+        self.replace_tabs_with_spaces = replace_tabs_with_spaces
+        self.tab_length = tab_length
+        self.line_break_handling = line_break_handling
+        self.line_break_repl = line_break_repl
+        self.dequote = dequote
+        self.is_escape_html_tag = is_escape_html_tag
+        self.is_escape_formula_injection = is_escape_formula_injection
+
+    def __repr__(self) -> str:
+        return ", ".join(
+            [
+                f"strip_str={self.strip_str!r}",
+                f"replace_tabs_with_spaces={self.replace_tabs_with_spaces}",
+                f"tab_length={self.tab_length}",
+                f"line_break_handling={self.line_break_handling}",
+                f"line_break_repl={self.line_break_repl}",
+                f"escape_html_tag={self.is_escape_html_tag}",
+                f"escape_formula_injection={self.is_escape_formula_injection}",
+            ]
+        )
+
+    def preprocess(self, data: Any) -> Tuple:
+        data, no_ansi_escape_data = self.__preprocess_string(
+            self.__preprocess_data(data, self.strip_str),
+        )
+        return (data, no_ansi_escape_data)
+
+    def update(self, **kwargs: Any) -> bool:
+        is_updated = False
+
+        for key, value in kwargs.items():
+            if not hasattr(self, key):
+                continue
+
+            if getattr(self, key) == value:
+                continue
+
+            setattr(self, key, value)
+            is_updated = True
+
+        return is_updated
+
+    def __preprocess_string(self, raw_data: Any) -> Tuple[Any, Optional[str]]:
+        data = raw_data
+
+        if not isinstance(data, str):
+            return (data, None)
+
+        if self.replace_tabs_with_spaces:
+            try:
+                data = data.replace("\t", " " * self.tab_length)
+            except (TypeError, AttributeError, ValueError):
+                pass
+
+        if self.is_escape_html_tag:
+            try:
+                data = html.escape(data)
+            except AttributeError:
+                return (data, None)
+
+        data = self.__process_line_break(data)
+        data = self.__escape_formula_injection(data)
+        data = self.__dequote(data)
+
+        try:
+            return (data, strip_ansi_escape(data))
+        except TypeError:
+            return (data, None)
+
+    @staticmethod
+    def __preprocess_data(data: Any, strip_str: Optional[Union[str, bytes]]) -> Any:
+        if strip_str is None:
+            return data
+
+        try:
+            return data.strip(strip_str)
+        except AttributeError:
+            return data
+        except UnicodeDecodeError:
+            return MultiByteStrDecoder(data).unicode_str.strip(strip_str)
+        except TypeError:
+            # reach here when data and strip_str type are different
+            if isinstance(data, bytes):
+                return MultiByteStrDecoder(data).unicode_str.strip(strip_str)
+            elif isinstance(strip_str, bytes):
+                return data.strip(MultiByteStrDecoder(strip_str).unicode_str)
+
+    def __dequote(self, s: str) -> str:
+        if not self.dequote or not s:
+            return s
+
+        try:
+            if (s[0] == s[-1]) and s.startswith(("'", '"')):
+                if s.count(s[0]) == 2:
+                    return s[1:-1]
+        except TypeError:
+            pass
+
+        return s
+
+    def __process_line_break(self, data: str) -> str:
+        lbh = self.line_break_handling
+
+        if lbh == LineBreakHandling.NOP:
+            return data
+
+        try:
+            if lbh == LineBreakHandling.REPLACE:
+                return _RE_LINE_BREAK.sub(self.line_break_repl, data)
+
+            if lbh == LineBreakHandling.ESCAPE:
+                return data.replace("\n", "\\n").replace("\r", "\\r")
+        except (TypeError, AttributeError):
+            return data
+
+        raise ValueError(f"unexpected line_break_handling: {lbh}")
+
+    def __escape_formula_injection(self, data: str) -> str:
+        if not self.is_escape_formula_injection:
+            return data
+
+        try:
+            if _RE_FORMULA_PREFIX.search(data):
+                return "'" + data
+        except (TypeError, AttributeError):
+            return data
+
+        return data

llmeval-env/lib/python3.10/site-packages/dataproperty/typing.py

@@ -0,0 +1,62 @@
+from datetime import datetime
+from decimal import Decimal
+from typing import Any, Callable, Mapping, Optional, Type, Union
+
+from typepy import (
+    Bool,
+    DateTime,
+    Dictionary,
+    Infinity,
+    Integer,
+    IpAddress,
+    List,
+    Nan,
+    NoneType,
+    NullString,
+    RealNumber,
+    String,
+    Typecode,
+)
+from typepy.type import AbstractType
+
+
+TypeHint = Optional[Type[AbstractType]]
+TransFunc = Callable[[Any], Any]
+DateTimeFormatter = Callable[[datetime], str]
+
+FloatType = Union[Type[Decimal], Type[float]]
+StrictLevelMap = Mapping[Union[str, Typecode], int]
+TypeValueMap = Mapping[Typecode, Union[float, Decimal, None]]
+
+_type_hint_map = {
+    # high frequently used types
+    "int": Integer,
+    "float": RealNumber,
+    "realnumber": RealNumber,
+    "str": String,
+    # low frequently used types
+    "bool": Bool,
+    "datetime": DateTime,
+    "dict": Dictionary,
+    "inf": Infinity,
+    "ip": IpAddress,
+    "list": List,
+    "nan": Nan,
+    "none": NoneType,
+    "nullstr": NullString,
+}
+
+
+def normalize_type_hint(type_hint: Union[str, TypeHint]) -> TypeHint:
+    if not type_hint:
+        return None
+
+    if not isinstance(type_hint, str):
+        return type_hint
+
+    type_hint = type_hint.strip().casefold()
+    for key, value in _type_hint_map.items():
+        if type_hint.startswith(key):
+            return value
+
+    raise ValueError(f"unknown typehint: {type_hint}")

llmeval-env/lib/python3.10/site-packages/datasets-2.19.1.dist-info/AUTHORS

@@ -0,0 +1,8 @@
+# This is the list of HuggingFace Datasets authors for copyright purposes.
+#
+# This does not necessarily list everyone who has contributed code, since in
+# some cases, their employer may be the copyright holder.  To see the full list
+# of contributors, see the revision history in source control.
+
+Google Inc.
+HuggingFace Inc.

llmeval-env/lib/python3.10/site-packages/datasets-2.19.1.dist-info/INSTALLER

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

llmeval-env/lib/python3.10/site-packages/datasets-2.19.1.dist-info/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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/datasets-2.19.1.dist-info/METADATA

@@ -0,0 +1,370 @@
+Metadata-Version: 2.1
+Name: datasets
+Version: 2.19.1
+Summary: HuggingFace community-driven open-source library of datasets
+Home-page: https://github.com/huggingface/datasets
+Author: HuggingFace Inc.
+Author-email: [email protected]
+License: Apache 2.0
+Download-URL: https://github.com/huggingface/datasets/tags
+Keywords: datasets machine learning datasets metrics
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: AUTHORS
+Requires-Dist: filelock
+Requires-Dist: numpy (>=1.17)
+Requires-Dist: pyarrow (>=12.0.0)
+Requires-Dist: pyarrow-hotfix
+Requires-Dist: dill (<0.3.9,>=0.3.0)
+Requires-Dist: pandas
+Requires-Dist: requests (>=2.19.0)
+Requires-Dist: tqdm (>=4.62.1)
+Requires-Dist: xxhash
+Requires-Dist: multiprocess
+Requires-Dist: fsspec[http] (<=2024.3.1,>=2023.1.0)
+Requires-Dist: aiohttp
+Requires-Dist: huggingface-hub (>=0.21.2)
+Requires-Dist: packaging
+Requires-Dist: pyyaml (>=5.1)
+Provides-Extra: apache-beam
+Requires-Dist: apache-beam (>=2.26.0) ; extra == 'apache-beam'
+Provides-Extra: audio
+Requires-Dist: soundfile (>=0.12.1) ; extra == 'audio'
+Requires-Dist: librosa ; extra == 'audio'
+Provides-Extra: benchmarks
+Requires-Dist: tensorflow (==2.12.0) ; extra == 'benchmarks'
+Requires-Dist: torch (==2.0.1) ; extra == 'benchmarks'
+Requires-Dist: transformers (==4.30.1) ; extra == 'benchmarks'
+Provides-Extra: dev
+Requires-Dist: absl-py ; extra == 'dev'
+Requires-Dist: joblib (<1.3.0) ; extra == 'dev'
+Requires-Dist: joblibspark ; extra == 'dev'
+Requires-Dist: pytest ; extra == 'dev'
+Requires-Dist: pytest-datadir ; extra == 'dev'
+Requires-Dist: pytest-xdist ; extra == 'dev'
+Requires-Dist: elasticsearch (<8.0.0) ; extra == 'dev'
+Requires-Dist: faiss-cpu (>=1.6.4) ; extra == 'dev'
+Requires-Dist: lz4 ; extra == 'dev'
+Requires-Dist: pyspark (>=3.4) ; extra == 'dev'
+Requires-Dist: py7zr ; extra == 'dev'
+Requires-Dist: rarfile (>=4.0) ; extra == 'dev'
+Requires-Dist: sqlalchemy ; extra == 'dev'
+Requires-Dist: s3fs (>=2021.11.1) ; extra == 'dev'
+Requires-Dist: protobuf (<4.0.0) ; extra == 'dev'
+Requires-Dist: tensorflow (>=2.6.0) ; extra == 'dev'
+Requires-Dist: tiktoken ; extra == 'dev'
+Requires-Dist: torch (>=2.0.0) ; extra == 'dev'
+Requires-Dist: soundfile (>=0.12.1) ; extra == 'dev'
+Requires-Dist: transformers ; extra == 'dev'
+Requires-Dist: typing-extensions (>=4.6.1) ; extra == 'dev'
+Requires-Dist: zstandard ; extra == 'dev'
+Requires-Dist: polars[timezone] (>=0.20.0) ; extra == 'dev'
+Requires-Dist: Pillow (>=6.2.1) ; extra == 'dev'
+Requires-Dist: librosa ; extra == 'dev'
+Requires-Dist: ruff (>=0.3.0) ; extra == 'dev'
+Requires-Dist: s3fs ; extra == 'dev'
+Requires-Dist: torch ; extra == 'dev'
+Requires-Dist: jax (>=0.3.14) ; (sys_platform != "win32") and extra == 'dev'
+Requires-Dist: jaxlib (>=0.3.14) ; (sys_platform != "win32") and extra == 'dev'
+Requires-Dist: apache-beam (>=2.26.0) ; (sys_platform != "win32" and python_version < "3.10") and extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: s3fs ; extra == 'docs'
+Requires-Dist: transformers ; extra == 'docs'
+Requires-Dist: torch ; extra == 'docs'
+Requires-Dist: tensorflow (>=2.6.0) ; extra == 'docs'
+Provides-Extra: jax
+Requires-Dist: jax (>=0.3.14) ; extra == 'jax'
+Requires-Dist: jaxlib (>=0.3.14) ; extra == 'jax'
+Provides-Extra: metrics-tests
+Requires-Dist: accelerate ; extra == 'metrics-tests'
+Requires-Dist: bert-score (>=0.3.6) ; extra == 'metrics-tests'
+Requires-Dist: jiwer ; extra == 'metrics-tests'
+Requires-Dist: langdetect ; extra == 'metrics-tests'
+Requires-Dist: mauve-text ; extra == 'metrics-tests'
+Requires-Dist: nltk ; extra == 'metrics-tests'
+Requires-Dist: rouge-score ; extra == 'metrics-tests'
+Requires-Dist: sacrebleu ; extra == 'metrics-tests'
+Requires-Dist: sacremoses ; extra == 'metrics-tests'
+Requires-Dist: scikit-learn ; extra == 'metrics-tests'
+Requires-Dist: scipy ; extra == 'metrics-tests'
+Requires-Dist: sentencepiece ; extra == 'metrics-tests'
+Requires-Dist: seqeval ; extra == 'metrics-tests'
+Requires-Dist: spacy (>=3.0.0) ; extra == 'metrics-tests'
+Requires-Dist: tldextract ; extra == 'metrics-tests'
+Requires-Dist: toml (>=0.10.1) ; extra == 'metrics-tests'
+Requires-Dist: typer (<0.5.0) ; extra == 'metrics-tests'
+Requires-Dist: requests-file (>=1.5.1) ; extra == 'metrics-tests'
+Requires-Dist: tldextract (>=3.1.0) ; extra == 'metrics-tests'
+Requires-Dist: texttable (>=1.6.3) ; extra == 'metrics-tests'
+Requires-Dist: Werkzeug (>=1.0.1) ; extra == 'metrics-tests'
+Requires-Dist: six (~=1.15.0) ; extra == 'metrics-tests'
+Provides-Extra: quality
+Requires-Dist: ruff (>=0.3.0) ; extra == 'quality'
+Provides-Extra: s3
+Requires-Dist: s3fs ; extra == 's3'
+Provides-Extra: streaming
+Provides-Extra: tensorflow
+Requires-Dist: tensorflow (>=2.6.0) ; extra == 'tensorflow'
+Provides-Extra: tensorflow_gpu
+Requires-Dist: tensorflow (>=2.6.0) ; extra == 'tensorflow_gpu'
+Provides-Extra: tests
+Requires-Dist: absl-py ; extra == 'tests'
+Requires-Dist: joblib (<1.3.0) ; extra == 'tests'
+Requires-Dist: joblibspark ; extra == 'tests'
+Requires-Dist: pytest ; extra == 'tests'
+Requires-Dist: pytest-datadir ; extra == 'tests'
+Requires-Dist: pytest-xdist ; extra == 'tests'
+Requires-Dist: elasticsearch (<8.0.0) ; extra == 'tests'
+Requires-Dist: faiss-cpu (>=1.6.4) ; extra == 'tests'
+Requires-Dist: lz4 ; extra == 'tests'
+Requires-Dist: pyspark (>=3.4) ; extra == 'tests'
+Requires-Dist: py7zr ; extra == 'tests'
+Requires-Dist: rarfile (>=4.0) ; extra == 'tests'
+Requires-Dist: sqlalchemy ; extra == 'tests'
+Requires-Dist: s3fs (>=2021.11.1) ; extra == 'tests'
+Requires-Dist: protobuf (<4.0.0) ; extra == 'tests'
+Requires-Dist: tensorflow (>=2.6.0) ; extra == 'tests'
+Requires-Dist: tiktoken ; extra == 'tests'
+Requires-Dist: torch (>=2.0.0) ; extra == 'tests'
+Requires-Dist: soundfile (>=0.12.1) ; extra == 'tests'
+Requires-Dist: transformers ; extra == 'tests'
+Requires-Dist: typing-extensions (>=4.6.1) ; extra == 'tests'
+Requires-Dist: zstandard ; extra == 'tests'
+Requires-Dist: polars[timezone] (>=0.20.0) ; extra == 'tests'
+Requires-Dist: Pillow (>=6.2.1) ; extra == 'tests'
+Requires-Dist: librosa ; extra == 'tests'
+Requires-Dist: jax (>=0.3.14) ; (sys_platform != "win32") and extra == 'tests'
+Requires-Dist: jaxlib (>=0.3.14) ; (sys_platform != "win32") and extra == 'tests'
+Requires-Dist: apache-beam (>=2.26.0) ; (sys_platform != "win32" and python_version < "3.10") and extra == 'tests'
+Provides-Extra: torch
+Requires-Dist: torch ; extra == 'torch'
+Provides-Extra: vision
+Requires-Dist: Pillow (>=6.2.1) ; extra == 'vision'
+
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://huggingface.co/datasets/huggingface/documentation-images/raw/main/datasets-logo-dark.svg">
+    <source media="(prefers-color-scheme: light)" srcset="https://huggingface.co/datasets/huggingface/documentation-images/raw/main/datasets-logo-light.svg">
+    <img alt="Hugging Face Datasets Library" src="https://huggingface.co/datasets/huggingface/documentation-images/raw/main/datasets-logo-light.svg" width="352" height="59" style="max-width: 100%;">
+  </picture>
+  <br/>
+  <br/>
+</p>
+
+<p align="center">
+    <a href="https://github.com/huggingface/datasets/actions/workflows/ci.yml?query=branch%3Amain">
+        <img alt="Build" src="https://github.com/huggingface/datasets/actions/workflows/ci.yml/badge.svg?branch=main">
+    </a>
+    <a href="https://github.com/huggingface/datasets/blob/main/LICENSE">
+        <img alt="GitHub" src="https://img.shields.io/github/license/huggingface/datasets.svg?color=blue">
+    </a>
+    <a href="https://huggingface.co/docs/datasets/index.html">
+        <img alt="Documentation" src="https://img.shields.io/website/http/huggingface.co/docs/datasets/index.html.svg?down_color=red&down_message=offline&up_message=online">
+    </a>
+    <a href="https://github.com/huggingface/datasets/releases">
+        <img alt="GitHub release" src="https://img.shields.io/github/release/huggingface/datasets.svg">
+    </a>
+    <a href="https://huggingface.co/datasets/">
+        <img alt="Number of datasets" src="https://img.shields.io/endpoint?url=https://huggingface.co/api/shields/datasets&color=brightgreen">
+    </a>
+    <a href="CODE_OF_CONDUCT.md">
+        <img alt="Contributor Covenant" src="https://img.shields.io/badge/Contributor%20Covenant-2.0-4baaaa.svg">
+    </a>
+    <a href="https://zenodo.org/badge/latestdoi/250213286"><img src="https://zenodo.org/badge/250213286.svg" alt="DOI"></a>
+</p>
+
+🤗 Datasets is a lightweight library providing **two** main features:
+
+- **one-line dataloaders for many public datasets**: one-liners to download and pre-process any of the ![number of datasets](https://img.shields.io/endpoint?url=https://huggingface.co/api/shields/datasets&color=brightgreen) major public datasets (image datasets, audio datasets, text datasets in 467 languages and dialects, etc.) provided on the [HuggingFace Datasets Hub](https://huggingface.co/datasets). With a simple command like `squad_dataset = load_dataset("squad")`, get any of these datasets ready to use in a dataloader for training/evaluating a ML model (Numpy/Pandas/PyTorch/TensorFlow/JAX),
+- **efficient data pre-processing**: simple, fast and reproducible data pre-processing for the public datasets as well as your own local datasets in CSV, JSON, text, PNG, JPEG, WAV, MP3, Parquet, etc. With simple commands like `processed_dataset = dataset.map(process_example)`, efficiently prepare the dataset for inspection and ML model evaluation and training.
+
+[🎓 **Documentation**](https://huggingface.co/docs/datasets/) [🔎 **Find a dataset in the Hub**](https://huggingface.co/datasets) [🌟 **Share a dataset on the Hub**](https://huggingface.co/docs/datasets/share)
+
+<h3 align="center">
+    <a href="https://hf.co/course"><img src="https://raw.githubusercontent.com/huggingface/datasets/main/docs/source/imgs/course_banner.png"></a>
+</h3>
+
+🤗 Datasets is designed to let the community easily add and share new datasets.
+
+🤗 Datasets has many additional interesting features:
+
+- Thrive on large datasets: 🤗 Datasets naturally frees the user from RAM memory limitation, all datasets are memory-mapped using an efficient zero-serialization cost backend (Apache Arrow).
+- Smart caching: never wait for your data to process several times.
+- Lightweight and fast with a transparent and pythonic API (multi-processing/caching/memory-mapping).
+- Built-in interoperability with NumPy, pandas, PyTorch, TensorFlow 2 and JAX.
+- Native support for audio and image data.
+- Enable streaming mode to save disk space and start iterating over the dataset immediately.
+
+🤗 Datasets originated from a fork of the awesome [TensorFlow Datasets](https://github.com/tensorflow/datasets) and the HuggingFace team want to deeply thank the TensorFlow Datasets team for building this amazing library. More details on the differences between 🤗 Datasets and `tfds` can be found in the section [Main differences between 🤗 Datasets and `tfds`](#main-differences-between--datasets-and-tfds).
+
+# Installation
+
+## With pip
+
+🤗 Datasets can be installed from PyPi and has to be installed in a virtual environment (venv or conda for instance)
+
+```bash
+pip install datasets
+```
+
+## With conda
+
+🤗 Datasets can be installed using conda as follows:
+
+```bash
+conda install -c huggingface -c conda-forge datasets
+```
+
+Follow the installation pages of TensorFlow and PyTorch to see how to install them with conda.
+
+For more details on installation, check the installation page in the documentation: https://huggingface.co/docs/datasets/installation
+
+## Installation to use with PyTorch/TensorFlow/pandas
+
+If you plan to use 🤗 Datasets with PyTorch (1.0+), TensorFlow (2.2+) or pandas, you should also install PyTorch, TensorFlow or pandas.
+
+For more details on using the library with NumPy, pandas, PyTorch or TensorFlow, check the quick start page in the documentation: https://huggingface.co/docs/datasets/quickstart
+
+# Usage
+
+🤗 Datasets is made to be very simple to use - the API is centered around a single function, `datasets.load_dataset(dataset_name, **kwargs)`, that instantiates a dataset.
+
+This library can be used for text/image/audio/etc. datasets. Here is an example to load a text dataset:
+
+Here is a quick example:
+
+```python
+from datasets import load_dataset
+
+# Print all the available datasets
+from huggingface_hub import list_datasets
+print([dataset.id for dataset in list_datasets()])
+
+# Load a dataset and print the first example in the training set
+squad_dataset = load_dataset('squad')
+print(squad_dataset['train'][0])
+
+# Process the dataset - add a column with the length of the context texts
+dataset_with_length = squad_dataset.map(lambda x: {"length": len(x["context"])})
+
+# Process the dataset - tokenize the context texts (using a tokenizer from the 🤗 Transformers library)
+from transformers import AutoTokenizer
+tokenizer = AutoTokenizer.from_pretrained('bert-base-cased')
+
+tokenized_dataset = squad_dataset.map(lambda x: tokenizer(x['context']), batched=True)
+```
+
+If your dataset is bigger than your disk or if you don't want to wait to download the data, you can use streaming:
+
+```python
+# If you want to use the dataset immediately and efficiently stream the data as you iterate over the dataset
+image_dataset = load_dataset('cifar100', streaming=True)
+for example in image_dataset["train"]:
+    break
+```
+
+For more details on using the library, check the quick start page in the documentation: https://huggingface.co/docs/datasets/quickstart and the specific pages on:
+
+- Loading a dataset: https://huggingface.co/docs/datasets/loading
+- What's in a Dataset: https://huggingface.co/docs/datasets/access
+- Processing data with 🤗 Datasets: https://huggingface.co/docs/datasets/process
+    - Processing audio data: https://huggingface.co/docs/datasets/audio_process
+    - Processing image data: https://huggingface.co/docs/datasets/image_process
+    - Processing text data: https://huggingface.co/docs/datasets/nlp_process
+- Streaming a dataset: https://huggingface.co/docs/datasets/stream
+- Writing your own dataset loading script: https://huggingface.co/docs/datasets/dataset_script
+- etc.
+
+# Add a new dataset to the Hub
+
+We have a very detailed step-by-step guide to add a new dataset to the ![number of datasets](https://img.shields.io/endpoint?url=https://huggingface.co/api/shields/datasets&color=brightgreen) datasets already provided on the [HuggingFace Datasets Hub](https://huggingface.co/datasets).
+
+You can find:
+- [how to upload a dataset to the Hub using your web browser or Python](https://huggingface.co/docs/datasets/upload_dataset) and also
+- [how to upload it using Git](https://huggingface.co/docs/datasets/share).
+
+# Main differences between 🤗 Datasets and `tfds`
+
+If you are familiar with the great TensorFlow Datasets, here are the main differences between 🤗 Datasets and `tfds`:
+
+- the scripts in 🤗 Datasets are not provided within the library but are queried, downloaded/cached and dynamically loaded upon request
+- the backend serialization of 🤗 Datasets is based on [Apache Arrow](https://arrow.apache.org/) instead of TF Records and leverage python dataclasses for info and features with some diverging features (we mostly don't do encoding and store the raw data as much as possible in the backend serialization cache).
+- the user-facing dataset object of 🤗 Datasets is not a `tf.data.Dataset` but a built-in framework-agnostic dataset class with methods inspired by what we like in `tf.data` (like a `map()` method). It basically wraps a memory-mapped Arrow table cache.
+
+# Disclaimers
+
+🤗 Datasets may run Python code defined by the dataset authors to parse certain data formats or structures. For security reasons, we ask users to:
+- check the dataset scripts they're going to run beforehand and
+- pin the `revision` of the repositories they use.
+
+If you're a dataset owner and wish to update any part of it (description, citation, license, etc.), or do not want your dataset to be included in the Hugging Face Hub, please get in touch by opening a discussion or a pull request in the Community tab of the dataset page. Thanks for your contribution to the ML community!
+
+## BibTeX
+
+If you want to cite our 🤗 Datasets library, you can use our [paper](https://arxiv.org/abs/2109.02846):
+
+```bibtex
+@inproceedings{lhoest-etal-2021-datasets,
+    title = "Datasets: A Community Library for Natural Language Processing",
+    author = "Lhoest, Quentin  and
+      Villanova del Moral, Albert  and
+      Jernite, Yacine  and
+      Thakur, Abhishek  and
+      von Platen, Patrick  and
+      Patil, Suraj  and
+      Chaumond, Julien  and
+      Drame, Mariama  and
+      Plu, Julien  and
+      Tunstall, Lewis  and
+      Davison, Joe  and
+      {\v{S}}a{\v{s}}ko, Mario  and
+      Chhablani, Gunjan  and
+      Malik, Bhavitvya  and
+      Brandeis, Simon  and
+      Le Scao, Teven  and
+      Sanh, Victor  and
+      Xu, Canwen  and
+      Patry, Nicolas  and
+      McMillan-Major, Angelina  and
+      Schmid, Philipp  and
+      Gugger, Sylvain  and
+      Delangue, Cl{\'e}ment  and
+      Matussi{\`e}re, Th{\'e}o  and
+      Debut, Lysandre  and
+      Bekman, Stas  and
+      Cistac, Pierric  and
+      Goehringer, Thibault  and
+      Mustar, Victor  and
+      Lagunas, Fran{\c{c}}ois  and
+      Rush, Alexander  and
+      Wolf, Thomas",
+    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing: System Demonstrations",
+    month = nov,
+    year = "2021",
+    address = "Online and Punta Cana, Dominican Republic",
+    publisher = "Association for Computational Linguistics",
+    url = "https://aclanthology.org/2021.emnlp-demo.21",
+    pages = "175--184",
+    abstract = "The scale, variety, and quantity of publicly-available NLP datasets has grown rapidly as researchers propose new tasks, larger models, and novel benchmarks. Datasets is a community library for contemporary NLP designed to support this ecosystem. Datasets aims to standardize end-user interfaces, versioning, and documentation, while providing a lightweight front-end that behaves similarly for small datasets as for internet-scale corpora. The design of the library incorporates a distributed, community-driven approach to adding datasets and documenting usage. After a year of development, the library now includes more than 650 unique datasets, has more than 250 contributors, and has helped support a variety of novel cross-dataset research projects and shared tasks. The library is available at https://github.com/huggingface/datasets.",
+    eprint={2109.02846},
+    archivePrefix={arXiv},
+    primaryClass={cs.CL},
+}
+```
+
+If you need to cite a specific version of our 🤗 Datasets library for reproducibility, you can use the corresponding version Zenodo DOI from this [list](https://zenodo.org/search?q=conceptrecid:%224817768%22&sort=-version&all_versions=True).
+
+

llmeval-env/lib/python3.10/site-packages/datasets-2.19.1.dist-info/RECORD

@@ -0,0 +1,274 @@
+../../../bin/datasets-cli,sha256=K-tpqks_eIrx2Yerd2SnheJGagjMuE6pK4dM_BD-VEw,263
+datasets-2.19.1.dist-info/AUTHORS,sha256=L0FBY23tCNHLmvsOKAbumHn8WZZIK98sH53JYxhAchU,327
+datasets-2.19.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+datasets-2.19.1.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+datasets-2.19.1.dist-info/METADATA,sha256=1bepJrLNSvCU9SILMtmGo4wSoaniJLCETh3VrZLzEjQ,19467
+datasets-2.19.1.dist-info/RECORD,,
+datasets-2.19.1.dist-info/WHEEL,sha256=OqRkF0eY5GHssMorFjlbTIq072vpHpF60fIQA6lS9xA,92
+datasets-2.19.1.dist-info/entry_points.txt,sha256=vhdg1JXUleCZtwvozP5q5iHqRpSETfyhSDJ39zW3KUA,70
+datasets-2.19.1.dist-info/top_level.txt,sha256=9A857YvCQm_Dg3UjeKkWPz9sDBos0t3zN2pf5krTemQ,9
+datasets/__init__.py,sha256=RbmsP1OwzxnzLbg9_Z69yD5LCCNzXpV5wwHc-XWVees,2455
+datasets/__pycache__/__init__.cpython-310.pyc,,
+datasets/__pycache__/arrow_dataset.cpython-310.pyc,,
+datasets/__pycache__/arrow_reader.cpython-310.pyc,,
+datasets/__pycache__/arrow_writer.cpython-310.pyc,,
+datasets/__pycache__/builder.bak.cpython-310.pyc,,
+datasets/__pycache__/builder.cpython-310.pyc,,
+datasets/__pycache__/combine.cpython-310.pyc,,
+datasets/__pycache__/config.cpython-310.pyc,,
+datasets/__pycache__/data_files.cpython-310.pyc,,
+datasets/__pycache__/dataset_dict.cpython-310.pyc,,
+datasets/__pycache__/distributed.cpython-310.pyc,,
+datasets/__pycache__/exceptions.cpython-310.pyc,,
+datasets/__pycache__/fingerprint.cpython-310.pyc,,
+datasets/__pycache__/info.cpython-310.pyc,,
+datasets/__pycache__/inspect.cpython-310.pyc,,
+datasets/__pycache__/iterable_dataset.cpython-310.pyc,,
+datasets/__pycache__/keyhash.cpython-310.pyc,,
+datasets/__pycache__/load.cpython-310.pyc,,
+datasets/__pycache__/metric.cpython-310.pyc,,
+datasets/__pycache__/naming.cpython-310.pyc,,
+datasets/__pycache__/search.cpython-310.pyc,,
+datasets/__pycache__/splits.cpython-310.pyc,,
+datasets/__pycache__/streaming.cpython-310.pyc,,
+datasets/__pycache__/table.cpython-310.pyc,,
+datasets/arrow_dataset.py,sha256=tQDkdMyyiQSNYZLat4Fe4qsIKEi-oSyhhhhjUhlmr3o,298474
+datasets/arrow_reader.py,sha256=xbU1VF-BBnX1qY8CaS9nlXILCExdPNtOuSI3TjoHM30,27236
+datasets/arrow_writer.py,sha256=0rtyqfWyAHFijbqv17kdRqOkwE1yxP6-JD3vpYpolEU,33637
+datasets/builder.bak.py,sha256=YZYHkGfXIFeM878CLLM0YvyrY6gLw3_z_MEh-QnCybE,111808
+datasets/builder.py,sha256=xvSKSAT05S-w0tSA3_UN65IDVoC_66_XzxmUPtVGI0E,111377
+datasets/combine.py,sha256=OvMg-5A_cBraHyEXbNTTrWjd9sbUiyA7PG6aBJpbg5Q,10924
+datasets/commands/__init__.py,sha256=rujbQtxJbwHhF9WQqp2DD9tfVTghDMJdl0v6H551Pcs,312
+datasets/commands/__pycache__/__init__.cpython-310.pyc,,
+datasets/commands/__pycache__/convert.cpython-310.pyc,,
+datasets/commands/__pycache__/convert_to_parquet.cpython-310.pyc,,
+datasets/commands/__pycache__/datasets_cli.cpython-310.pyc,,
+datasets/commands/__pycache__/dummy_data.cpython-310.pyc,,
+datasets/commands/__pycache__/env.cpython-310.pyc,,
+datasets/commands/__pycache__/run_beam.cpython-310.pyc,,
+datasets/commands/__pycache__/test.cpython-310.pyc,,
+datasets/commands/convert.py,sha256=-VOqHh0ySkIOfEYmR7HVs7PzouVrkVShqyUtNGcNCYU,7914
+datasets/commands/convert_to_parquet.py,sha256=-_a683Kl8pHDAlO1izUfn_ToTo7vbnTGkTnazK0Xrok,5833
+datasets/commands/datasets_cli.py,sha256=2X_zweHbPFV9KYfcdXiJCS4QXzUGfIyM7ZbOKiz88JU,1519
+datasets/commands/dummy_data.py,sha256=rBVQAN1wd9fvldw79PVoL3vNZdqosjO_PPO_SFEYUqw,23106
+datasets/commands/env.py,sha256=8qg-hpXSXXsHvtYFvJkn5rn9IncqPsjjx3nR8no4a2I,1239
+datasets/commands/run_beam.py,sha256=Dg8migMADmQvUg0koc2MN-yOQts8olBw548gCejNuwM,7010
+datasets/commands/test.py,sha256=zpkyGlt0fOkAEq1RxDbZjrzpGMjM6Lt8PWC81ZZnEKA,8785
+datasets/config.py,sha256=bDKBe082TfxQHyH8CKIdBPEMQ4cNIimM_EkJMtOnMYU,10505
+datasets/data_files.py,sha256=ismMV0qNJDy3uKyp7n2jUacZOx6TFS02N6EzJITsPw8,32222
+datasets/dataset_dict.py,sha256=6jFex2mNY0obSame0DWffVDbzTw5vKeHP25AWPCbLQQ,105682
+datasets/distributed.py,sha256=jZ31II0mmlPMhZbEtbAsX6jlK0U69qdpV3uS5U5JFYw,1560
+datasets/download/__init__.py,sha256=lbFOtITDaR7PHrhzJ8VfRnpaOT6NYozSxUcLv_GVfTg,281
+datasets/download/__pycache__/__init__.cpython-310.pyc,,
+datasets/download/__pycache__/download_config.cpython-310.pyc,,
+datasets/download/__pycache__/download_manager.cpython-310.pyc,,
+datasets/download/__pycache__/mock_download_manager.cpython-310.pyc,,
+datasets/download/__pycache__/streaming_download_manager.cpython-310.pyc,,
+datasets/download/download_config.py,sha256=I2OBuePpZsZoktzBarjq4SJjJHM-1biTiletBPad8go,5097
+datasets/download/download_manager.py,sha256=Fvz0FDBrmaH8gYfobcKeaT6p4gaCos9m0sjY3F8vKmg,17213
+datasets/download/mock_download_manager.py,sha256=jpMYk8SFjqnoR9J-8qqldQyKCtzjCnUXKPkSp3og7DY,10351
+datasets/download/streaming_download_manager.py,sha256=eqFKHDWSaP2bZpaDQIJbUIvZOSb6r6P1Kj4Ko7qGTVI,7339
+datasets/exceptions.py,sha256=vUgW0Ow6qTG1p1XhhUcoVHz71L7upBsNU6L_teiW5XU,3163
+datasets/features/__init__.py,sha256=D-O0b8-LWEcTHxADhKkQriOSlNBIUsWlfOU5WfD9AD0,445
+datasets/features/__pycache__/__init__.cpython-310.pyc,,
+datasets/features/__pycache__/audio.cpython-310.pyc,,
+datasets/features/__pycache__/features.cpython-310.pyc,,
+datasets/features/__pycache__/image.cpython-310.pyc,,
+datasets/features/__pycache__/translation.cpython-310.pyc,,
+datasets/features/audio.py,sha256=8_xpCxr5jyCM9zemFWTZK6mNfXv6VeF_3stNdQx0JFA,12225
+datasets/features/features.py,sha256=ORF9sJjRZqa_6Njz0dLmIdNip45uZpam0BlM_hfQK6Q,89689
+datasets/features/image.py,sha256=JoBseOcKuoa4d04xu-sQylvGWVURhZfJPml4pSTHDnQ,15526
+datasets/features/translation.py,sha256=J6jxAcAPakmMwtaHhHAhDENi1AgIGmeNn4neuEeFWYg,4476
+datasets/filesystems/__init__.py,sha256=lJ2GgJp4goEsGb2UQuILf12BwSyT3WbO1EN55tRX5Os,2282
+datasets/filesystems/__pycache__/__init__.cpython-310.pyc,,
+datasets/filesystems/__pycache__/compression.cpython-310.pyc,,
+datasets/filesystems/__pycache__/s3filesystem.cpython-310.pyc,,
+datasets/filesystems/compression.py,sha256=UkqXFsMgiDtqXbwZNZ-PUtg26bOXyEv-avnN85OFLwI,4299
+datasets/filesystems/s3filesystem.py,sha256=KowTCvTSsrdAU4syiaRffNw4g25-DTbjsoXBIMWz2tk,5725
+datasets/fingerprint.py,sha256=pDq49L1aSrD9WXyfEVsR0rt28jDdW7rj7CiTykbIMRo,22040
+datasets/formatting/__init__.py,sha256=7WIy1k5cCRDk9-HyMA2EdzeZdxaB50hie_wOAEAZ0TE,5473
+datasets/formatting/__pycache__/__init__.cpython-310.pyc,,
+datasets/formatting/__pycache__/formatting.cpython-310.pyc,,
+datasets/formatting/__pycache__/jax_formatter.cpython-310.pyc,,
+datasets/formatting/__pycache__/np_formatter.cpython-310.pyc,,
+datasets/formatting/__pycache__/polars_formatter.cpython-310.pyc,,
+datasets/formatting/__pycache__/tf_formatter.cpython-310.pyc,,
+datasets/formatting/__pycache__/torch_formatter.cpython-310.pyc,,
+datasets/formatting/formatting.py,sha256=uq2z8ifT_q09Fp3mTa563LUiuVHsFI0SZLTNfVzXRrw,25853
+datasets/formatting/jax_formatter.py,sha256=KoTbq0XSUQ1Rp3G5IzN3cU192JZ9t5HAZtHiVpHPbB4,6839
+datasets/formatting/np_formatter.py,sha256=DJBnt3oF0fHWJCqe4j6o9BOupZ0uGrw_xxFfsGBVoyk,4525
+datasets/formatting/polars_formatter.py,sha256=PoOZM4RLFvAJdRZyNG5w3aOps3W3Saq1F8Mfyapgv8I,4700
+datasets/formatting/tf_formatter.py,sha256=QRzeq8f1ALa6961PBNFRTH3RT4S-_8soqfUl9a7F89I,4657
+datasets/formatting/torch_formatter.py,sha256=s6bP2ktOa8GXkjXq46odn1VpnzZhHN4Wrh7JUP9_3Y0,4728
+datasets/info.py,sha256=R-o9Uv97SUoSI_SV4_HQQX7rJx6RHHWFfFmGIrnmeWg,26789
+datasets/inspect.py,sha256=CFZ-Z1l9umEZRftcBNXecEq9I47gMAC-0JOCg3QCRqA,26400
+datasets/io/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/io/__pycache__/__init__.cpython-310.pyc,,
+datasets/io/__pycache__/abc.cpython-310.pyc,,
+datasets/io/__pycache__/csv.cpython-310.pyc,,
+datasets/io/__pycache__/generator.cpython-310.pyc,,
+datasets/io/__pycache__/json.cpython-310.pyc,,
+datasets/io/__pycache__/parquet.cpython-310.pyc,,
+datasets/io/__pycache__/spark.cpython-310.pyc,,
+datasets/io/__pycache__/sql.cpython-310.pyc,,
+datasets/io/__pycache__/text.cpython-310.pyc,,
+datasets/io/abc.py,sha256=LwDMXYs6YkhZuz1JiMK4PDIqgNjv7I8xH3UMUELW2ys,1672
+datasets/io/csv.py,sha256=v4zaWehHb9U3njbdhy7wQnb8qO_c_58XOUC9JgBBVwI,5265
+datasets/io/generator.py,sha256=mHPZLq376-RQfq9bwxDp7EHjyCJKG242gaPWUmTNA5E,1788
+datasets/io/json.py,sha256=_0PwV7ps8In3HQpNNJpYtdmafMEmQsF1lr74YuCRLlg,6459
+datasets/io/parquet.py,sha256=qnPUUITsm-shWK2_6FcJE6rlRwivr97d7ghP0IT5QZA,5832
+datasets/io/spark.py,sha256=VUIODLHgIbiK0CI0UvthQ_gUO0MQDtHUozvw7Dfs8FI,1797
+datasets/io/sql.py,sha256=4Zjw7peVEhhzoDtz2VTCFPqt2Tpy4zMB7T7ajb2GVTY,4234
+datasets/io/text.py,sha256=bebEzXBSGC40_Gy94j9ZTJ7Hg0IfrV_4pnIUEhQZVig,1975
+datasets/iterable_dataset.py,sha256=IVlqE9PBtXT0jd9WXrCZ7cAcYiwCS8LCOiuIw70wAZ8,108229
+datasets/keyhash.py,sha256=gZLJ-0lIaj5mXP3fm0zFz8oY9L3Qu_OMkgil06oq0eg,3872
+datasets/load.py,sha256=q28Y1Sn9EXQO9iJNiQwT8WWCNGsU-oVzy_FiG63eyS0,126783
+datasets/metric.py,sha256=BDyIxMAC7i9lGDrRcJjeMN1sxEcfXHGX29_SfTVfC3c,28065
+datasets/naming.py,sha256=aqQqYG4QR8YoxJJMAUyVv_oQyudm4WAApsEHvcozpNg,3001
+datasets/packaged_modules/__init__.py,sha256=-lAu9yy5otjt3GM5q_MeL4f628PMazSXpFcpYY5saXE,3018
+datasets/packaged_modules/__pycache__/__init__.cpython-310.pyc,,
+datasets/packaged_modules/arrow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/arrow/__pycache__/__init__.cpython-310.pyc,,
+datasets/packaged_modules/arrow/__pycache__/arrow.cpython-310.pyc,,
+datasets/packaged_modules/arrow/arrow.py,sha256=xIAV0IJoFiyjgRckRYrz-rt1JI081VMvliAQHYW4h8E,3378
+datasets/packaged_modules/audiofolder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/audiofolder/__pycache__/__init__.cpython-310.pyc,,
+datasets/packaged_modules/audiofolder/__pycache__/audiofolder.cpython-310.pyc,,
+datasets/packaged_modules/audiofolder/audiofolder.py,sha256=BXRlK57KvYdyEo-L-Qs6qtrG2tL0QUF0cmJvl6L1N-w,1633
+datasets/packaged_modules/cache/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/cache/__pycache__/__init__.cpython-310.pyc,,
+datasets/packaged_modules/cache/__pycache__/cache.cpython-310.pyc,,
+datasets/packaged_modules/cache/cache.py,sha256=XYXcLgZQRh8O85W-omwsnAJ9ZN3F1xz462PvU1n485o,8909
+datasets/packaged_modules/csv/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/csv/__pycache__/__init__.cpython-310.pyc,,
+datasets/packaged_modules/csv/__pycache__/csv.cpython-310.pyc,,
+datasets/packaged_modules/csv/csv.py,sha256=WCcsVrf85iua__7F_Kaq2a5DmiNIHEqRcx2zv8G-5Dw,8874
+datasets/packaged_modules/folder_based_builder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/folder_based_builder/__pycache__/__init__.cpython-310.pyc,,
+datasets/packaged_modules/folder_based_builder/__pycache__/folder_based_builder.cpython-310.pyc,,
+datasets/packaged_modules/folder_based_builder/folder_based_builder.py,sha256=cpTdV7db71rYaB0eiRF0wyVaXQp2LArfm06Xc7hxap0,22509
+datasets/packaged_modules/generator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/generator/__pycache__/__init__.cpython-310.pyc,,
+datasets/packaged_modules/generator/__pycache__/generator.cpython-310.pyc,,
+datasets/packaged_modules/generator/generator.py,sha256=QZKrNB3ztWPXT_H5OFOl1CBlAlAeckW48kdyySyVVKw,928
+datasets/packaged_modules/imagefolder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/imagefolder/__pycache__/__init__.cpython-310.pyc,,
+datasets/packaged_modules/imagefolder/__pycache__/imagefolder.cpython-310.pyc,,
+datasets/packaged_modules/imagefolder/imagefolder.py,sha256=SYu6yxe4iBZzclT7u3m0gaACa6udSi1YOfFSy7dzdwk,1975
+datasets/packaged_modules/json/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/json/__pycache__/__init__.cpython-310.pyc,,
+datasets/packaged_modules/json/__pycache__/json.cpython-310.pyc,,
+datasets/packaged_modules/json/json.py,sha256=xHsMHKRbPMjh8TZHr87-IVCl2fIhiQ1Pw7jwcga8a4k,9959
+datasets/packaged_modules/pandas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/pandas/__pycache__/__init__.cpython-310.pyc,,
+datasets/packaged_modules/pandas/__pycache__/pandas.cpython-310.pyc,,
+datasets/packaged_modules/pandas/pandas.py,sha256=SyVcaveIKo5X_fMXLArzZcKcQQxomtvUhulAS9Sd9wE,2485
+datasets/packaged_modules/parquet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/parquet/__pycache__/__init__.cpython-310.pyc,,
+datasets/packaged_modules/parquet/__pycache__/parquet.cpython-310.pyc,,
+datasets/packaged_modules/parquet/parquet.py,sha256=dhJcVASXIYCoify8pCUms9_Ofvjb20W9ouvQGkVStm4,4892
+datasets/packaged_modules/spark/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/spark/__pycache__/__init__.cpython-310.pyc,,
+datasets/packaged_modules/spark/__pycache__/spark.cpython-310.pyc,,
+datasets/packaged_modules/spark/spark.py,sha256=7z8KuKSRVxvmdNekgAVWC5ULP3OFR-iUdXhhkLOF-kU,13916
+datasets/packaged_modules/sql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/sql/__pycache__/__init__.cpython-310.pyc,,
+datasets/packaged_modules/sql/__pycache__/sql.cpython-310.pyc,,
+datasets/packaged_modules/sql/sql.py,sha256=Fcnok2-1uX2XnQah4BrtE5SPli6O3JKb9tzMy1lachk,4482
+datasets/packaged_modules/text/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/text/__pycache__/__init__.cpython-310.pyc,,
+datasets/packaged_modules/text/__pycache__/text.cpython-310.pyc,,
+datasets/packaged_modules/text/text.py,sha256=B9TOS7SfIVTXWJtW_0rW6EgDGzsQ-kPZadxE39eqK4g,6321
+datasets/packaged_modules/webdataset/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/webdataset/__pycache__/__init__.cpython-310.pyc,,
+datasets/packaged_modules/webdataset/__pycache__/_tenbin.cpython-310.pyc,,
+datasets/packaged_modules/webdataset/__pycache__/webdataset.cpython-310.pyc,,
+datasets/packaged_modules/webdataset/_tenbin.py,sha256=oovYsgR2R3eXSn1xSCLG3oTly1szKDP4UOiRp4ORdIk,8533
+datasets/packaged_modules/webdataset/webdataset.py,sha256=CvN6UGdQtx__JT3Pxc0nlUPYFAbCjuSclYsCJ48hY8o,8768
+datasets/parallel/__init__.py,sha256=dEhpBOLbCcsKClTXYJnJRp-ZtrfUV6jsH-CYqviXl-E,89
+datasets/parallel/__pycache__/__init__.cpython-310.pyc,,
+datasets/parallel/__pycache__/parallel.cpython-310.pyc,,
+datasets/parallel/parallel.py,sha256=E-oOQ6zwKrkLFPwZ-3EOcr_aANJDhE-d6QTq7Mp7WvA,4738
+datasets/search.py,sha256=oUh55M77KOxHU-V4ZFVosHCj3IaAOWJJ8bmkGD1aXxw,35606
+datasets/splits.py,sha256=2FY6TPAvkBDhU4szbgHcOZTtKgngtNKE6noCmfhLP6U,23509
+datasets/streaming.py,sha256=A04UAT5VeFrAn7t6gODgnxb7DgJvONLW-22uESg6-Fo,6540
+datasets/table.py,sha256=EnBYIQQUpA_74DtAJwjADCS_udSNdemoFg61XouTY-8,95048
+datasets/tasks/__init__.py,sha256=ExUcieN-G7_ybwfGqi3-Kt3akv3hrnlCq_RwEosFhiY,1614
+datasets/tasks/__pycache__/__init__.cpython-310.pyc,,
+datasets/tasks/__pycache__/audio_classification.cpython-310.pyc,,
+datasets/tasks/__pycache__/automatic_speech_recognition.cpython-310.pyc,,
+datasets/tasks/__pycache__/base.cpython-310.pyc,,
+datasets/tasks/__pycache__/image_classification.cpython-310.pyc,,
+datasets/tasks/__pycache__/language_modeling.cpython-310.pyc,,
+datasets/tasks/__pycache__/question_answering.cpython-310.pyc,,
+datasets/tasks/__pycache__/summarization.cpython-310.pyc,,
+datasets/tasks/__pycache__/text_classification.cpython-310.pyc,,
+datasets/tasks/audio_classification.py,sha256=fkR37qfJfJRPgCizf9iDV-dBnsGmLo2V0w8JpMwyX0M,1297
+datasets/tasks/automatic_speech_recognition.py,sha256=zbTTsLX5N-_Da5oucuk6zBZhDdhD4N5_rzsni9lT_vo,1309
+datasets/tasks/base.py,sha256=SlYEeDS87jruZNNkDRgz-U4q7EUijePL-RTN14ngwsk,1095
+datasets/tasks/image_classification.py,sha256=llF5_koN5APq7cF_WlGy5c9hAVspRlYCprXgwAa7kCc,1297
+datasets/tasks/language_modeling.py,sha256=Vdor-TdCGdiMpaIPZr0fRvgNrt5_D-1JElXKGbfQhvI,581
+datasets/tasks/question_answering.py,sha256=z8a80QRTsouUuIYVKQRDMTxOGeSK1QMycyDHxUW42zg,1105
+datasets/tasks/summarization.py,sha256=adrpmvgfAjXCyDRdZnZ52h0FKql5-EWU61Z2-v6rN-w,772
+datasets/tasks/text_classification.py,sha256=KvlddXxnnzzjCjJmyY3Z-e1G4dpTN0UXqlmZ1L0LrjU,1403
+datasets/utils/__init__.py,sha256=Y7X1Xnrg4L-YdtclluausV1giXB0_JbR9SEw9UfVw1Q,1013
+datasets/utils/__pycache__/__init__.cpython-310.pyc,,
+datasets/utils/__pycache__/_dataset_viewer.cpython-310.pyc,,
+datasets/utils/__pycache__/_dill.cpython-310.pyc,,
+datasets/utils/__pycache__/_filelock.cpython-310.pyc,,
+datasets/utils/__pycache__/beam_utils.cpython-310.pyc,,
+datasets/utils/__pycache__/cache.cpython-310.pyc,,
+datasets/utils/__pycache__/deprecation_utils.cpython-310.pyc,,
+datasets/utils/__pycache__/doc_utils.cpython-310.pyc,,
+datasets/utils/__pycache__/download_manager.cpython-310.pyc,,
+datasets/utils/__pycache__/experimental.cpython-310.pyc,,
+datasets/utils/__pycache__/extract.cpython-310.pyc,,
+datasets/utils/__pycache__/file_utils.cpython-310.pyc,,
+datasets/utils/__pycache__/filelock.cpython-310.pyc,,
+datasets/utils/__pycache__/hub.cpython-310.pyc,,
+datasets/utils/__pycache__/info_utils.cpython-310.pyc,,
+datasets/utils/__pycache__/logging.cpython-310.pyc,,
+datasets/utils/__pycache__/metadata.cpython-310.pyc,,
+datasets/utils/__pycache__/patching.cpython-310.pyc,,
+datasets/utils/__pycache__/py_utils.cpython-310.pyc,,
+datasets/utils/__pycache__/readme.cpython-310.pyc,,
+datasets/utils/__pycache__/sharding.cpython-310.pyc,,
+datasets/utils/__pycache__/stratify.cpython-310.pyc,,
+datasets/utils/__pycache__/tf_utils.cpython-310.pyc,,
+datasets/utils/__pycache__/tqdm.cpython-310.pyc,,
+datasets/utils/__pycache__/track.cpython-310.pyc,,
+datasets/utils/__pycache__/typing.cpython-310.pyc,,
+datasets/utils/__pycache__/version.cpython-310.pyc,,
+datasets/utils/_dataset_viewer.py,sha256=L9gqrMGS6FgmEJps2uBK7HFFPFENrL881ZKIVAiaF-E,4438
+datasets/utils/_dill.py,sha256=_qM3dQ_9sYQg5PrQdGuzpNvdRhf1nLgYQNF4MZAaZ-8,16916
+datasets/utils/_filelock.py,sha256=yl4ZQupEUyPu7f8D2ZCXitIMlajDu322QcO7Fio8eQI,2370
+datasets/utils/beam_utils.py,sha256=DvA0ZVrx4-T9iHpB9VpduKn435p4rFaJw0Ua5cKmpeI,2029
+datasets/utils/cache.py,sha256=ouFjySURlby2H9KqJLfpRBM8H1Fwiuo3LBlfZAB-OPo,10557
+datasets/utils/deprecation_utils.py,sha256=hTHwlzRs92NfNVudH71LMpW70sjbsP5amebrIgi3A-U,3452
+datasets/utils/doc_utils.py,sha256=HoSm0TFaQaCYGfDgNhpBJ4Xc2WQZuOD6dTxLd9D87fs,407
+datasets/utils/download_manager.py,sha256=AXDA-dUNUOmmy4Z7e8A34BJtQPcbJhWSQuO4p5wnDWY,60
+datasets/utils/experimental.py,sha256=JgOjaEY3RWZ--3u0-ry82gLCDUpudfBfl-hWZ46SyS4,1097
+datasets/utils/extract.py,sha256=Pw00NNW-vbmTfHduB-YCBEaw8qEmR4z_Ira7ZMiSlXs,14189
+datasets/utils/file_utils.py,sha256=C4zLt-y4qJfVFIFa9T6qUd1SaWRNdTfsiqn1vYeBU7I,65451
+datasets/utils/filelock.py,sha256=H6C5dQGFCzVKyeDRRY8fZ4YGTEvvNd-MTjpL_sWYb5k,352
+datasets/utils/hub.py,sha256=V2JGolL5VjFT0YiEhI0sxJED_9tGdvma7lH22d64S9I,130
+datasets/utils/info_utils.py,sha256=uadj74BSn08F75wNanZkf-7z3Yo6aVoFNO8zMkJfmkk,5050
+datasets/utils/logging.py,sha256=a9kgqN1Xo6HvsIPbrHY08n7cUukxQqd3vpwTubisL3E,5404
+datasets/utils/metadata.py,sha256=EXuwMc0s3jgksgglAFYERpKUd5deEsjQZq5wlIImjUM,12440
+datasets/utils/patching.py,sha256=iTeb7XG4faLJKNylq55EcZyCndUXU_XBDvOOkuDz_sc,4955
+datasets/utils/py_utils.py,sha256=YsBGk9CGEEH3LOsHeQ2_xNKCLABeMl1YgKTjCI24Awg,27624
+datasets/utils/readme.py,sha256=JFlaLMCGrIz0nQCdnYKUZk5d9D9DErEYfjtRrX9VzIw,12627
+datasets/utils/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/utils/resources/__pycache__/__init__.cpython-310.pyc,,
+datasets/utils/resources/creators.json,sha256=XtIpMZefgBOdTevRrQTkFiufbgCbp_iyxseyphYQkn0,257
+datasets/utils/resources/languages.json,sha256=Z0rQNPsfje8zMi8KdvvwxF4APwwqcskJFUvhNiLAgPM,199138
+datasets/utils/resources/multilingualities.json,sha256=02Uc8RtRzfl13l98Y_alZm5HuMYwPzL78B0S5a1X-8c,205
+datasets/utils/resources/readme_structure.yaml,sha256=hNf9msoBZw5jfakQrDb0Af8T325TXdcaHsAO2MUcZvY,3877
+datasets/utils/resources/size_categories.json,sha256=_5nAP7z8R6t7_GfER81QudFO6Y1tqYu4AWrr4Aot8S8,171
+datasets/utils/sharding.py,sha256=FDi895opKH7XkpfIu-ag9PqBQo2PGx0tSO3Dg-gDAAs,4288
+datasets/utils/stratify.py,sha256=uMwuCDRbW342vy-lXDHs6IQusOr7c9nOG3PpnWyzJO4,4091
+datasets/utils/tf_utils.py,sha256=YWmXP525b-kp1A-pnF-rGEOKqmg0Dv5j8RXJieSbkZc,25044
+datasets/utils/tqdm.py,sha256=44F0g2fBpJwShh1l88PP7Z8kBihFWA_Yee4sjiQSxes,4303
+datasets/utils/track.py,sha256=k0HYom1uxmEvYdIOMei6ie39mrrOBmf-Qd0HAYVnfag,1407
+datasets/utils/typing.py,sha256=LznosIqUzjXgwbRLAGCv4_7-yZo7muYY42Y3495oz5I,224
+datasets/utils/version.py,sha256=Z82cHpjTbQVJyWgnwSU8DsW2G0y-sSbSoOVeQrAds9k,3281

llmeval-env/lib/python3.10/site-packages/datasets-2.19.1.dist-info/WHEEL

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

llmeval-env/lib/python3.10/site-packages/datasets-2.19.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+datasets-cli = datasets.commands.datasets_cli:main
+

llmeval-env/lib/python3.10/site-packages/datasets-2.19.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+datasets

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

@@ -0,0 +1,68 @@
+###################################################################
+#  Numexpr - Fast numerical array expression evaluator for NumPy.
+#
+#      License: MIT
+#      Author:  See AUTHORS.txt
+#
+#  See LICENSE.txt and LICENSES/*.txt for details about copyright and
+#  rights to use.
+####################################################################
+
+"""
+Numexpr is a fast numerical expression evaluator for NumPy.  With it,
+expressions that operate on arrays (like "3*a+4*b") are accelerated
+and use less memory than doing the same calculation in Python.
+
+See:
+
+https://github.com/pydata/numexpr
+
+for more info about it.
+
+"""
+
+from numexpr.interpreter import MAX_THREADS, use_vml, __BLOCK_SIZE1__
+
+is_cpu_amd_intel = False # DEPRECATION WARNING: WILL BE REMOVED IN FUTURE RELEASE
+
+# cpuinfo imports were moved into the test submodule function that calls them 
+# to improve import times.
+
+import os, os.path
+import platform
+from numexpr.expressions import E
+from numexpr.necompiler import (NumExpr, disassemble, evaluate, re_evaluate, 
+    validate)
+
+from numexpr.utils import (_init_num_threads,
+    get_vml_version, set_vml_accuracy_mode, set_vml_num_threads,
+    set_num_threads, get_num_threads,
+    detect_number_of_cores, detect_number_of_threads)
+
+# Detect the number of cores
+ncores = detect_number_of_cores()
+# Initialize the number of threads to be used
+nthreads = _init_num_threads()
+# The default for VML is 1 thread (see #39)
+# set_vml_num_threads(1)
+
+from . import version
+__version__ = version.version
+
+def print_versions():
+    """Print the versions of software that numexpr relies on."""
+    try:
+        import numexpr.tests
+        return numexpr.tests.print_versions()
+    except ImportError:
+        # To maintain Python 2.6 compatibility we have simple error handling
+        raise ImportError('`numexpr.tests` could not be imported, likely it was excluded from the distribution.')
+
+def test(verbosity=1):
+    """Run all the tests in the test suite."""
+    try:
+        import numexpr.tests
+        return numexpr.tests.test(verbosity=verbosity)
+    except ImportError:
+        # To maintain Python 2.6 compatibility we have simple error handling
+        raise ImportError('`numexpr.tests` could not be imported, likely it was excluded from the distribution.')

llmeval-env/lib/python3.10/site-packages/numexpr/cpuinfo.py

@@ -0,0 +1,859 @@
+###################################################################
+#  cpuinfo - Get information about CPU
+#
+#      License: BSD
+#      Author:  Pearu Peterson <[email protected]>
+#
+#  See LICENSES/cpuinfo.txt for details about copyright and
+#  rights to use.
+####################################################################
+
+"""
+cpuinfo
+
+Copyright 2002 Pearu Peterson all rights reserved,
+Pearu Peterson <[email protected]>
+Permission to use, modify, and distribute this software is given under the
+terms of the NumPy (BSD style) license.  See LICENSE.txt that came with
+this distribution for specifics.
+
+NO WARRANTY IS EXPRESSED OR IMPLIED.  USE AT YOUR OWN RISK.
+Pearu Peterson
+"""
+
+__all__ = ['cpu']
+
+import sys, re, types
+import os
+import subprocess
+import warnings
+import platform
+import inspect
+
+is_cpu_amd_intel = False # DEPRECATION WARNING: WILL BE REMOVED IN FUTURE RELEASE
+
+def getoutput(cmd, successful_status=(0,), stacklevel=1):
+    try:
+        p = subprocess.Popen(cmd, stdout=subprocess.PIPE)
+        output, _ = p.communicate()
+        status = p.returncode
+    except EnvironmentError as e:
+        warnings.warn(str(e), UserWarning, stacklevel=stacklevel)
+        return False, ''
+    if os.WIFEXITED(status) and os.WEXITSTATUS(status) in successful_status:
+        return True, output
+    return False, output
+
+
+def command_info(successful_status=(0,), stacklevel=1, **kw):
+    info = {}
+    for key in kw:
+        ok, output = getoutput(kw[key], successful_status=successful_status,
+                               stacklevel=stacklevel + 1)
+        if ok:
+            info[key] = output.strip()
+    return info
+
+
+def command_by_line(cmd, successful_status=(0,), stacklevel=1):
+    ok, output = getoutput(cmd, successful_status=successful_status,
+                           stacklevel=stacklevel + 1)
+    if not ok:
+        return
+
+    # XXX: check
+    output = output.decode('ascii')
+
+    for line in output.splitlines():
+        yield line.strip()
+
+
+def key_value_from_command(cmd, sep, successful_status=(0,),
+                           stacklevel=1):
+    d = {}
+    for line in command_by_line(cmd, successful_status=successful_status,
+                                stacklevel=stacklevel + 1):
+        l = [s.strip() for s in line.split(sep, 1)]
+        if len(l) == 2:
+            d[l[0]] = l[1]
+    return d
+
+
+class CPUInfoBase(object):
+    """Holds CPU information and provides methods for requiring
+    the availability of various CPU features.
+    """
+
+    def _try_call(self, func):
+        try:
+            return func()
+        except:
+            pass
+
+    def __getattr__(self, name):
+        if not name.startswith('_'):
+            if hasattr(self, '_' + name):
+                attr = getattr(self, '_' + name)
+                if inspect.ismethod(attr):
+                    return lambda func=self._try_call, attr=attr: func(attr)
+            else:
+                return lambda: None
+        raise AttributeError(name)
+
+    def _getNCPUs(self):
+        return 1
+
+    def __get_nbits(self):
+        abits = platform.architecture()[0]
+        nbits = re.compile(r'(\d+)bit').search(abits).group(1)
+        return nbits
+
+    def _is_32bit(self):
+        return self.__get_nbits() == '32'
+
+    def _is_64bit(self):
+        return self.__get_nbits() == '64'
+
+
+class LinuxCPUInfo(CPUInfoBase):
+    info = None
+
+    def __init__(self):
+        if self.info is not None:
+            return
+        info = [{}]
+        ok, output = getoutput(['uname', '-m'])
+        if ok:
+            info[0]['uname_m'] = output.strip()
+        try:
+            fo = open('/proc/cpuinfo')
+        except EnvironmentError as e:
+            warnings.warn(str(e), UserWarning)
+        else:
+            for line in fo:
+                name_value = [s.strip() for s in line.split(':', 1)]
+                if len(name_value) != 2:
+                    continue
+                name, value = name_value
+                if not info or name in info[-1]:  # next processor
+                    info.append({})
+                info[-1][name] = value
+            fo.close()
+        self.__class__.info = info
+
+    def _not_impl(self):
+        pass
+
+    # Athlon
+
+    def _is_AMD(self):
+        return self.info[0]['vendor_id'] == 'AuthenticAMD'
+
+    def _is_AthlonK6_2(self):
+        return self._is_AMD() and self.info[0]['model'] == '2'
+
+    def _is_AthlonK6_3(self):
+        return self._is_AMD() and self.info[0]['model'] == '3'
+
+    def _is_AthlonK6(self):
+        return re.match(r'.*?AMD-K6', self.info[0]['model name']) is not None
+
+    def _is_AthlonK7(self):
+        return re.match(r'.*?AMD-K7', self.info[0]['model name']) is not None
+
+    def _is_AthlonMP(self):
+        return re.match(r'.*?Athlon\(tm\) MP\b',
+                        self.info[0]['model name']) is not None
+
+    def _is_AMD64(self):
+        return self.is_AMD() and self.info[0]['family'] == '15'
+
+    def _is_Athlon64(self):
+        return re.match(r'.*?Athlon\(tm\) 64\b',
+                        self.info[0]['model name']) is not None
+
+    def _is_AthlonHX(self):
+        return re.match(r'.*?Athlon HX\b',
+                        self.info[0]['model name']) is not None
+
+    def _is_Opteron(self):
+        return re.match(r'.*?Opteron\b',
+                        self.info[0]['model name']) is not None
+
+    def _is_Hammer(self):
+        return re.match(r'.*?Hammer\b',
+                        self.info[0]['model name']) is not None
+
+    # Alpha
+
+    def _is_Alpha(self):
+        return self.info[0]['cpu'] == 'Alpha'
+
+    def _is_EV4(self):
+        return self.is_Alpha() and self.info[0]['cpu model'] == 'EV4'
+
+    def _is_EV5(self):
+        return self.is_Alpha() and self.info[0]['cpu model'] == 'EV5'
+
+    def _is_EV56(self):
+        return self.is_Alpha() and self.info[0]['cpu model'] == 'EV56'
+
+    def _is_PCA56(self):
+        return self.is_Alpha() and self.info[0]['cpu model'] == 'PCA56'
+
+    # Intel
+
+    #XXX
+    _is_i386 = _not_impl
+
+    def _is_Intel(self):
+        return self.info[0]['vendor_id'] == 'GenuineIntel'
+
+    def _is_i486(self):
+        return self.info[0]['cpu'] == 'i486'
+
+    def _is_i586(self):
+        return self.is_Intel() and self.info[0]['cpu family'] == '5'
+
+    def _is_i686(self):
+        return self.is_Intel() and self.info[0]['cpu family'] == '6'
+
+    def _is_Celeron(self):
+        return re.match(r'.*?Celeron',
+                        self.info[0]['model name']) is not None
+
+    def _is_Pentium(self):
+        return re.match(r'.*?Pentium',
+                        self.info[0]['model name']) is not None
+
+    def _is_PentiumII(self):
+        return re.match(r'.*?Pentium.*?II\b',
+                        self.info[0]['model name']) is not None
+
+    def _is_PentiumPro(self):
+        return re.match(r'.*?PentiumPro\b',
+                        self.info[0]['model name']) is not None
+
+    def _is_PentiumMMX(self):
+        return re.match(r'.*?Pentium.*?MMX\b',
+                        self.info[0]['model name']) is not None
+
+    def _is_PentiumIII(self):
+        return re.match(r'.*?Pentium.*?III\b',
+                        self.info[0]['model name']) is not None
+
+    def _is_PentiumIV(self):
+        return re.match(r'.*?Pentium.*?(IV|4)\b',
+                        self.info[0]['model name']) is not None
+
+    def _is_PentiumM(self):
+        return re.match(r'.*?Pentium.*?M\b',
+                        self.info[0]['model name']) is not None
+
+    def _is_Prescott(self):
+        return self.is_PentiumIV() and self.has_sse3()
+
+    def _is_Nocona(self):
+        return (self.is_Intel() and
+                self.info[0]['cpu family'] in ('6', '15') and
+                # two s sse3; three s ssse3 not the same thing, this is fine
+                (self.has_sse3() and not self.has_ssse3()) and
+                re.match(r'.*?\blm\b', self.info[0]['flags']) is not None)
+
+    def _is_Core2(self):
+        return (self.is_64bit() and self.is_Intel() and
+                re.match(r'.*?Core\(TM\)2\b',
+                         self.info[0]['model name']) is not None)
+
+    def _is_Itanium(self):
+        return re.match(r'.*?Itanium\b',
+                        self.info[0]['family']) is not None
+
+    def _is_XEON(self):
+        return re.match(r'.*?XEON\b',
+                        self.info[0]['model name'], re.IGNORECASE) is not None
+
+    _is_Xeon = _is_XEON
+
+    # Power
+    def _is_Power(self):
+        return re.match(r'.*POWER.*',
+                       self.info[0]['cpu']) is not None
+
+    def _is_Power7(self):
+        return re.match(r'.*POWER7.*',
+                       self.info[0]['cpu']) is not None
+
+    def _is_Power8(self):
+        return re.match(r'.*POWER8.*',
+                       self.info[0]['cpu']) is not None
+
+    def _is_Power9(self):
+        return re.match(r'.*POWER9.*',
+                       self.info[0]['cpu']) is not None
+
+    def _has_Altivec(self):
+        return re.match(r'.*altivec\ supported.*',
+                       self.info[0]['cpu']) is not None
+
+    # Varia
+
+    def _is_singleCPU(self):
+        return len(self.info) == 1
+
+    def _getNCPUs(self):
+        return len(self.info)
+
+    def _has_fdiv_bug(self):
+        return self.info[0]['fdiv_bug'] == 'yes'
+
+    def _has_f00f_bug(self):
+        return self.info[0]['f00f_bug'] == 'yes'
+
+    def _has_mmx(self):
+        return re.match(r'.*?\bmmx\b', self.info[0]['flags']) is not None
+
+    def _has_sse(self):
+        return re.match(r'.*?\bsse\b', self.info[0]['flags']) is not None
+
+    def _has_sse2(self):
+        return re.match(r'.*?\bsse2\b', self.info[0]['flags']) is not None
+
+    def _has_sse3(self):
+        return re.match(r'.*?\bpni\b', self.info[0]['flags']) is not None
+
+    def _has_ssse3(self):
+        return re.match(r'.*?\bssse3\b', self.info[0]['flags']) is not None
+
+    def _has_3dnow(self):
+        return re.match(r'.*?\b3dnow\b', self.info[0]['flags']) is not None
+
+    def _has_3dnowext(self):
+        return re.match(r'.*?\b3dnowext\b', self.info[0]['flags']) is not None
+
+
+class IRIXCPUInfo(CPUInfoBase):
+    info = None
+
+    def __init__(self):
+        if self.info is not None:
+            return
+        info = key_value_from_command('sysconf', sep=' ',
+                                      successful_status=(0, 1))
+        self.__class__.info = info
+
+    def _not_impl(self):
+        pass
+
+    def _is_singleCPU(self):
+        return self.info.get('NUM_PROCESSORS') == '1'
+
+    def _getNCPUs(self):
+        return int(self.info.get('NUM_PROCESSORS', 1))
+
+    def __cputype(self, n):
+        return self.info.get('PROCESSORS').split()[0].lower() == 'r%s' % (n)
+
+    def _is_r2000(self):
+        return self.__cputype(2000)
+
+    def _is_r3000(self):
+        return self.__cputype(3000)
+
+    def _is_r3900(self):
+        return self.__cputype(3900)
+
+    def _is_r4000(self):
+        return self.__cputype(4000)
+
+    def _is_r4100(self):
+        return self.__cputype(4100)
+
+    def _is_r4300(self):
+        return self.__cputype(4300)
+
+    def _is_r4400(self):
+        return self.__cputype(4400)
+
+    def _is_r4600(self):
+        return self.__cputype(4600)
+
+    def _is_r4650(self):
+        return self.__cputype(4650)
+
+    def _is_r5000(self):
+        return self.__cputype(5000)
+
+    def _is_r6000(self):
+        return self.__cputype(6000)
+
+    def _is_r8000(self):
+        return self.__cputype(8000)
+
+    def _is_r10000(self):
+        return self.__cputype(10000)
+
+    def _is_r12000(self):
+        return self.__cputype(12000)
+
+    def _is_rorion(self):
+        return self.__cputype('orion')
+
+    def get_ip(self):
+        try:
+            return self.info.get('MACHINE')
+        except:
+            pass
+
+    def __machine(self, n):
+        return self.info.get('MACHINE').lower() == 'ip%s' % (n)
+
+    def _is_IP19(self):
+        return self.__machine(19)
+
+    def _is_IP20(self):
+        return self.__machine(20)
+
+    def _is_IP21(self):
+        return self.__machine(21)
+
+    def _is_IP22(self):
+        return self.__machine(22)
+
+    def _is_IP22_4k(self):
+        return self.__machine(22) and self._is_r4000()
+
+    def _is_IP22_5k(self):
+        return self.__machine(22) and self._is_r5000()
+
+    def _is_IP24(self):
+        return self.__machine(24)
+
+    def _is_IP25(self):
+        return self.__machine(25)
+
+    def _is_IP26(self):
+        return self.__machine(26)
+
+    def _is_IP27(self):
+        return self.__machine(27)
+
+    def _is_IP28(self):
+        return self.__machine(28)
+
+    def _is_IP30(self):
+        return self.__machine(30)
+
+    def _is_IP32(self):
+        return self.__machine(32)
+
+    def _is_IP32_5k(self):
+        return self.__machine(32) and self._is_r5000()
+
+    def _is_IP32_10k(self):
+        return self.__machine(32) and self._is_r10000()
+
+
+class DarwinCPUInfo(CPUInfoBase):
+    info = None
+
+    def __init__(self):
+        if self.info is not None:
+            return
+        info = command_info(arch='arch',
+                            machine='machine')
+        info['sysctl_hw'] = key_value_from_command(['sysctl', 'hw'], sep='=')
+        self.__class__.info = info
+
+    def _not_impl(self): pass
+
+    def _getNCPUs(self):
+        return int(self.info['sysctl_hw'].get('hw.ncpu', 1))
+
+    def _is_Power_Macintosh(self):
+        return self.info['sysctl_hw']['hw.machine'] == 'Power Macintosh'
+
+    def _is_i386(self):
+        return self.info['arch'] == 'i386'
+
+    def _is_ppc(self):
+        return self.info['arch'] == 'ppc'
+
+    def __machine(self, n):
+        return self.info['machine'] == 'ppc%s' % n
+
+    def _is_ppc601(self): return self.__machine(601)
+
+    def _is_ppc602(self): return self.__machine(602)
+
+    def _is_ppc603(self): return self.__machine(603)
+
+    def _is_ppc603e(self): return self.__machine('603e')
+
+    def _is_ppc604(self): return self.__machine(604)
+
+    def _is_ppc604e(self): return self.__machine('604e')
+
+    def _is_ppc620(self): return self.__machine(620)
+
+    def _is_ppc630(self): return self.__machine(630)
+
+    def _is_ppc740(self): return self.__machine(740)
+
+    def _is_ppc7400(self): return self.__machine(7400)
+
+    def _is_ppc7450(self): return self.__machine(7450)
+
+    def _is_ppc750(self): return self.__machine(750)
+
+    def _is_ppc403(self): return self.__machine(403)
+
+    def _is_ppc505(self): return self.__machine(505)
+
+    def _is_ppc801(self): return self.__machine(801)
+
+    def _is_ppc821(self): return self.__machine(821)
+
+    def _is_ppc823(self): return self.__machine(823)
+
+    def _is_ppc860(self): return self.__machine(860)
+
+class NetBSDCPUInfo(CPUInfoBase):
+	info = None
+
+	def __init__(self):
+		if self.info is not None:
+			return
+		info = {}
+		info['sysctl_hw'] = key_value_from_command(['sysctl', 'hw'], sep='=')
+		info['arch'] = info['sysctl_hw'].get('hw.machine_arch', 1)
+		info['machine'] = info['sysctl_hw'].get('hw.machine', 1)
+		self.__class__.info = info
+
+	def _not_impl(self): pass
+
+	def _getNCPUs(self):
+		return int(self.info['sysctl_hw'].get('hw.ncpu', 1))
+
+	def _is_Intel(self):
+		if self.info['sysctl_hw'].get('hw.model', "")[0:5] == 'Intel':
+			return True
+		return False
+
+	def _is_AMD(self):
+		if self.info['sysctl_hw'].get('hw.model', "")[0:3] == 'AMD':
+			return True
+		return False
+
+class SunOSCPUInfo(CPUInfoBase):
+    info = None
+
+    def __init__(self):
+        if self.info is not None:
+            return
+        info = command_info(arch='arch',
+                            mach='mach',
+                            uname_i=['uname', '-i'],
+                            isainfo_b=['isainfo', '-b'],
+                            isainfo_n=['isainfo', '-n'],
+        )
+        info['uname_X'] = key_value_from_command(['uname', '-X'], sep='=')
+        for line in command_by_line(['psrinfo', '-v', '0']):
+            m = re.match(r'\s*The (?P<p>[\w\d]+) processor operates at', line)
+            if m:
+                info['processor'] = m.group('p')
+                break
+        self.__class__.info = info
+
+    def _not_impl(self):
+        pass
+
+    def _is_i386(self):
+        return self.info['isainfo_n'] == 'i386'
+
+    def _is_sparc(self):
+        return self.info['isainfo_n'] == 'sparc'
+
+    def _is_sparcv9(self):
+        return self.info['isainfo_n'] == 'sparcv9'
+
+    def _getNCPUs(self):
+        return int(self.info['uname_X'].get('NumCPU', 1))
+
+    def _is_sun4(self):
+        return self.info['arch'] == 'sun4'
+
+    def _is_SUNW(self):
+        return re.match(r'SUNW', self.info['uname_i']) is not None
+
+    def _is_sparcstation5(self):
+        return re.match(r'.*SPARCstation-5', self.info['uname_i']) is not None
+
+    def _is_ultra1(self):
+        return re.match(r'.*Ultra-1', self.info['uname_i']) is not None
+
+    def _is_ultra250(self):
+        return re.match(r'.*Ultra-250', self.info['uname_i']) is not None
+
+    def _is_ultra2(self):
+        return re.match(r'.*Ultra-2', self.info['uname_i']) is not None
+
+    def _is_ultra30(self):
+        return re.match(r'.*Ultra-30', self.info['uname_i']) is not None
+
+    def _is_ultra4(self):
+        return re.match(r'.*Ultra-4', self.info['uname_i']) is not None
+
+    def _is_ultra5_10(self):
+        return re.match(r'.*Ultra-5_10', self.info['uname_i']) is not None
+
+    def _is_ultra5(self):
+        return re.match(r'.*Ultra-5', self.info['uname_i']) is not None
+
+    def _is_ultra60(self):
+        return re.match(r'.*Ultra-60', self.info['uname_i']) is not None
+
+    def _is_ultra80(self):
+        return re.match(r'.*Ultra-80', self.info['uname_i']) is not None
+
+    def _is_ultraenterprice(self):
+        return re.match(r'.*Ultra-Enterprise', self.info['uname_i']) is not None
+
+    def _is_ultraenterprice10k(self):
+        return re.match(r'.*Ultra-Enterprise-10000', self.info['uname_i']) is not None
+
+    def _is_sunfire(self):
+        return re.match(r'.*Sun-Fire', self.info['uname_i']) is not None
+
+    def _is_ultra(self):
+        return re.match(r'.*Ultra', self.info['uname_i']) is not None
+
+    def _is_cpusparcv7(self):
+        return self.info['processor'] == 'sparcv7'
+
+    def _is_cpusparcv8(self):
+        return self.info['processor'] == 'sparcv8'
+
+    def _is_cpusparcv9(self):
+        return self.info['processor'] == 'sparcv9'
+
+
+class Win32CPUInfo(CPUInfoBase):
+    info = None
+    pkey = r"HARDWARE\DESCRIPTION\System\CentralProcessor"
+    # XXX: what does the value of
+    #   HKEY_LOCAL_MACHINE\HARDWARE\DESCRIPTION\System\CentralProcessor\0
+    # mean?
+
+    def __init__(self):
+        try:
+            import _winreg
+        except ImportError:  # Python 3
+            import winreg as _winreg
+
+        if self.info is not None:
+            return
+        info = []
+        try:
+            #XXX: Bad style to use so long `try:...except:...`. Fix it!
+
+            prgx = re.compile(r"family\s+(?P<FML>\d+)\s+model\s+(?P<MDL>\d+)"
+                              r"\s+stepping\s+(?P<STP>\d+)", re.IGNORECASE)
+            chnd = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, self.pkey)
+            pnum = 0
+            while 1:
+                try:
+                    proc = _winreg.EnumKey(chnd, pnum)
+                except _winreg.error:
+                    break
+                else:
+                    pnum += 1
+                    info.append({"Processor": proc})
+                    phnd = _winreg.OpenKey(chnd, proc)
+                    pidx = 0
+                    while True:
+                        try:
+                            name, value, vtpe = _winreg.EnumValue(phnd, pidx)
+                        except _winreg.error:
+                            break
+                        else:
+                            pidx = pidx + 1
+                            info[-1][name] = value
+                            if name == "Identifier":
+                                srch = prgx.search(value)
+                                if srch:
+                                    info[-1]["Family"] = int(srch.group("FML"))
+                                    info[-1]["Model"] = int(srch.group("MDL"))
+                                    info[-1]["Stepping"] = int(srch.group("STP"))
+        except:
+            print(sys.exc_value, '(ignoring)')
+        self.__class__.info = info
+
+    def _not_impl(self):
+        pass
+
+    # Athlon
+
+    def _is_AMD(self):
+        return self.info[0]['VendorIdentifier'] == 'AuthenticAMD'
+
+    def _is_Am486(self):
+        return self.is_AMD() and self.info[0]['Family'] == 4
+
+    def _is_Am5x86(self):
+        return self.is_AMD() and self.info[0]['Family'] == 4
+
+    def _is_AMDK5(self):
+        return (self.is_AMD() and self.info[0]['Family'] == 5 and
+                self.info[0]['Model'] in [0, 1, 2, 3])
+
+    def _is_AMDK6(self):
+        return (self.is_AMD() and self.info[0]['Family'] == 5 and
+                self.info[0]['Model'] in [6, 7])
+
+    def _is_AMDK6_2(self):
+        return (self.is_AMD() and self.info[0]['Family'] == 5 and
+                self.info[0]['Model'] == 8)
+
+    def _is_AMDK6_3(self):
+        return (self.is_AMD() and self.info[0]['Family'] == 5 and
+                self.info[0]['Model'] == 9)
+
+    def _is_AMDK7(self):
+        return self.is_AMD() and self.info[0]['Family'] == 6
+
+    # To reliably distinguish between the different types of AMD64 chips
+    # (Athlon64, Operton, Athlon64 X2, Semperon, Turion 64, etc.) would
+    # require looking at the 'brand' from cpuid
+
+    def _is_AMD64(self):
+        return self.is_AMD() and self.info[0]['Family'] == 15
+
+    # Intel
+
+    def _is_Intel(self):
+        return self.info[0]['VendorIdentifier'] == 'GenuineIntel'
+
+    def _is_i386(self):
+        return self.info[0]['Family'] == 3
+
+    def _is_i486(self):
+        return self.info[0]['Family'] == 4
+
+    def _is_i586(self):
+        return self.is_Intel() and self.info[0]['Family'] == 5
+
+    def _is_i686(self):
+        return self.is_Intel() and self.info[0]['Family'] == 6
+
+    def _is_Pentium(self):
+        return self.is_Intel() and self.info[0]['Family'] == 5
+
+    def _is_PentiumMMX(self):
+        return (self.is_Intel() and self.info[0]['Family'] == 5 and
+                self.info[0]['Model'] == 4)
+
+    def _is_PentiumPro(self):
+        return (self.is_Intel() and self.info[0]['Family'] == 6 and
+                self.info[0]['Model'] == 1)
+
+    def _is_PentiumII(self):
+        return (self.is_Intel() and self.info[0]['Family'] == 6 and
+                self.info[0]['Model'] in [3, 5, 6])
+
+    def _is_PentiumIII(self):
+        return (self.is_Intel() and self.info[0]['Family'] == 6 and
+                self.info[0]['Model'] in [7, 8, 9, 10, 11])
+
+    def _is_PentiumIV(self):
+        return self.is_Intel() and self.info[0]['Family'] == 15
+
+    def _is_PentiumM(self):
+        return (self.is_Intel() and self.info[0]['Family'] == 6 and
+                self.info[0]['Model'] in [9, 13, 14])
+
+    def _is_Core2(self):
+        return (self.is_Intel() and self.info[0]['Family'] == 6 and
+                self.info[0]['Model'] in [15, 16, 17])
+
+    # Varia
+
+    def _is_singleCPU(self):
+        return len(self.info) == 1
+
+    def _getNCPUs(self):
+        return len(self.info)
+
+    def _has_mmx(self):
+        if self.is_Intel():
+            return ((self.info[0]['Family'] == 5 and
+                     self.info[0]['Model'] == 4) or
+                    (self.info[0]['Family'] in [6, 15]))
+        elif self.is_AMD():
+            return self.info[0]['Family'] in [5, 6, 15]
+        else:
+            return False
+
+    def _has_sse(self):
+        if self.is_Intel():
+            return ((self.info[0]['Family'] == 6 and
+                     self.info[0]['Model'] in [7, 8, 9, 10, 11]) or
+                    self.info[0]['Family'] == 15)
+        elif self.is_AMD():
+            return ((self.info[0]['Family'] == 6 and
+                     self.info[0]['Model'] in [6, 7, 8, 10]) or
+                    self.info[0]['Family'] == 15)
+        else:
+            return False
+
+    def _has_sse2(self):
+        if self.is_Intel():
+            return self.is_Pentium4() or self.is_PentiumM() or self.is_Core2()
+        elif self.is_AMD():
+            return self.is_AMD64()
+        else:
+            return False
+
+    def _has_3dnow(self):
+        return self.is_AMD() and self.info[0]['Family'] in [5, 6, 15]
+
+    def _has_3dnowext(self):
+        return self.is_AMD() and self.info[0]['Family'] in [6, 15]
+
+
+if sys.platform.startswith('linux'):  # variations: linux2,linux-i386 (any others?)
+    cpuinfo = LinuxCPUInfo
+elif sys.platform.startswith('irix'):
+    cpuinfo = IRIXCPUInfo
+elif sys.platform == 'darwin':
+    cpuinfo = DarwinCPUInfo
+elif sys.platform[0:6] == 'netbsd':
+    cpuinfo = NetBSDCPUInfo
+elif sys.platform.startswith('sunos'):
+    cpuinfo = SunOSCPUInfo
+elif sys.platform.startswith('win32'):
+    cpuinfo = Win32CPUInfo
+elif sys.platform.startswith('cygwin'):
+    cpuinfo = LinuxCPUInfo
+#XXX: other OS's. Eg. use _winreg on Win32. Or os.uname on unices.
+else:
+    cpuinfo = CPUInfoBase
+
+cpu = cpuinfo()
+
+if __name__ == "__main__":
+
+    cpu.is_blaa()
+    cpu.is_Intel()
+    cpu.is_Alpha()
+
+    info = []
+    for name in dir(cpuinfo):
+        if name[0] == '_' and name[1] != '_':
+            r = getattr(cpu, name[1:])()
+            if r:
+                if r != 1:
+                    info.append('%s=%s' % (name[1:], r))
+                else:
+                    info.append(name[1:])
+    print('CPU information: ' + ' '.join(info))

llmeval-env/lib/python3.10/site-packages/nvidia_cuda_runtime_cu12-12.1.105.dist-info/INSTALLER

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

llmeval-env/lib/python3.10/site-packages/nvidia_cuda_runtime_cu12-12.1.105.dist-info/License.txt

@@ -0,0 +1,1568 @@
+End User License Agreement
+--------------------------
+
+
+Preface
+-------
+
+The Software License Agreement in Chapter 1 and the Supplement
+in Chapter 2 contain license terms and conditions that govern
+the use of NVIDIA software. By accepting this agreement, you
+agree to comply with all the terms and conditions applicable
+to the product(s) included herein.
+
+
+NVIDIA Driver
+
+
+Description
+
+This package contains the operating system driver and
+fundamental system software components for NVIDIA GPUs.
+
+
+NVIDIA CUDA Toolkit
+
+
+Description
+
+The NVIDIA CUDA Toolkit provides command-line and graphical
+tools for building, debugging and optimizing the performance
+of applications accelerated by NVIDIA GPUs, runtime and math
+libraries, and documentation including programming guides,
+user manuals, and API references.
+
+
+Default Install Location of CUDA Toolkit
+
+Windows platform:
+
+%ProgramFiles%\NVIDIA GPU Computing Toolkit\CUDA\v#.#
+
+Linux platform:
+
+/usr/local/cuda-#.#
+
+Mac platform:
+
+/Developer/NVIDIA/CUDA-#.#
+
+
+NVIDIA CUDA Samples
+
+
+Description
+
+This package includes over 100+ CUDA examples that demonstrate
+various CUDA programming principles, and efficient CUDA
+implementation of algorithms in specific application domains.
+
+
+Default Install Location of CUDA Samples
+
+Windows platform:
+
+%ProgramData%\NVIDIA Corporation\CUDA Samples\v#.#
+
+Linux platform:
+
+/usr/local/cuda-#.#/samples
+
+and
+
+$HOME/NVIDIA_CUDA-#.#_Samples
+
+Mac platform:
+
+/Developer/NVIDIA/CUDA-#.#/samples
+
+
+NVIDIA Nsight Visual Studio Edition (Windows only)
+
+
+Description
+
+NVIDIA Nsight Development Platform, Visual Studio Edition is a
+development environment integrated into Microsoft Visual
+Studio that provides tools for debugging, profiling, analyzing
+and optimizing your GPU computing and graphics applications.
+
+
+Default Install Location of Nsight Visual Studio Edition
+
+Windows platform:
+
+%ProgramFiles(x86)%\NVIDIA Corporation\Nsight Visual Studio Edition #.#
+
+
+1. License Agreement for NVIDIA Software Development Kits
+---------------------------------------------------------
+
+
+Release Date: July 26, 2018
+---------------------------
+
+
+Important NoticeRead before downloading, installing,
+copying or using the licensed software:
+-------------------------------------------------------
+
+This license agreement, including exhibits attached
+("Agreement”) is a legal agreement between you and NVIDIA
+Corporation ("NVIDIA") and governs your use of a NVIDIA
+software development kit (“SDK”).
+
+Each SDK has its own set of software and materials, but here
+is a description of the types of items that may be included in
+a SDK: source code, header files, APIs, data sets and assets
+(examples include images, textures, models, scenes, videos,
+native API input/output files), binary software, sample code,
+libraries, utility programs, programming code and
+documentation.
+
+This Agreement can be accepted only by an adult of legal age
+of majority in the country in which the SDK is used.
+
+If you are entering into this Agreement on behalf of a company
+or other legal entity, you represent that you have the legal
+authority to bind the entity to this Agreement, in which case
+“you” will mean the entity you represent.
+
+If you don’t have the required age or authority to accept
+this Agreement, or if you don’t accept all the terms and
+conditions of this Agreement, do not download, install or use
+the SDK.
+
+You agree to use the SDK only for purposes that are permitted
+by (a) this Agreement, and (b) any applicable law, regulation
+or generally accepted practices or guidelines in the relevant
+jurisdictions.
+
+
+1.1. License
+
+
+1.1.1. License Grant
+
+Subject to the terms of this Agreement, NVIDIA hereby grants
+you a non-exclusive, non-transferable license, without the
+right to sublicense (except as expressly provided in this
+Agreement) to:
+
+  1. Install and use the SDK,
+
+  2. Modify and create derivative works of sample source code
+    delivered in the SDK, and
+
+  3. Distribute those portions of the SDK that are identified
+    in this Agreement as distributable, as incorporated in
+    object code format into a software application that meets
+    the distribution requirements indicated in this Agreement.
+
+
+1.1.2. Distribution Requirements
+
+These are the distribution requirements for you to exercise
+the distribution grant:
+
+  1. Your application must have material additional
+    functionality, beyond the included portions of the SDK.
+
+  2. The distributable portions of the SDK shall only be
+    accessed by your application.
+
+  3. The following notice shall be included in modifications
+    and derivative works of sample source code distributed:
+    “This software contains source code provided by NVIDIA
+    Corporation.”
+
+  4. Unless a developer tool is identified in this Agreement
+    as distributable, it is delivered for your internal use
+    only.
+
+  5. The terms under which you distribute your application
+    must be consistent with the terms of this Agreement,
+    including (without limitation) terms relating to the
+    license grant and license restrictions and protection of
+    NVIDIA’s intellectual property rights. Additionally, you
+    agree that you will protect the privacy, security and
+    legal rights of your application users.
+
+  6. You agree to notify NVIDIA in writing of any known or
+    suspected distribution or use of the SDK not in compliance
+    with the requirements of this Agreement, and to enforce
+    the terms of your agreements with respect to distributed
+    SDK.
+
+
+1.1.3. Authorized Users
+
+You may allow employees and contractors of your entity or of
+your subsidiary(ies) to access and use the SDK from your
+secure network to perform work on your behalf.
+
+If you are an academic institution you may allow users
+enrolled or employed by the academic institution to access and
+use the SDK from your secure network.
+
+You are responsible for the compliance with the terms of this
+Agreement by your authorized users. If you become aware that
+your authorized users didn’t follow the terms of this
+Agreement, you agree to take reasonable steps to resolve the
+non-compliance and prevent new occurrences.
+
+
+1.1.4. Pre-Release SDK
+
+The SDK versions identified as alpha, beta, preview or
+otherwise as pre-release, may not be fully functional, may
+contain errors or design flaws, and may have reduced or
+different security, privacy, accessibility, availability, and
+reliability standards relative to commercial versions of
+NVIDIA software and materials. Use of a pre-release SDK may
+result in unexpected results, loss of data, project delays or
+other unpredictable damage or loss.
+
+You may use a pre-release SDK at your own risk, understanding
+that pre-release SDKs are not intended for use in production
+or business-critical systems.
+
+NVIDIA may choose not to make available a commercial version
+of any pre-release SDK. NVIDIA may also choose to abandon
+development and terminate the availability of a pre-release
+SDK at any time without liability.
+
+
+1.1.5. Updates
+
+NVIDIA may, at its option, make available patches, workarounds
+or other updates to this SDK. Unless the updates are provided
+with their separate governing terms, they are deemed part of
+the SDK licensed to you as provided in this Agreement. You
+agree that the form and content of the SDK that NVIDIA
+provides may change without prior notice to you. While NVIDIA
+generally maintains compatibility between versions, NVIDIA may
+in some cases make changes that introduce incompatibilities in
+future versions of the SDK.
+
+
+1.1.6. Third Party Licenses
+
+The SDK may come bundled with, or otherwise include or be
+distributed with, third party software licensed by a NVIDIA
+supplier and/or open source software provided under an open
+source license. Use of third party software is subject to the
+third-party license terms, or in the absence of third party
+terms, the terms of this Agreement. Copyright to third party
+software is held by the copyright holders indicated in the
+third-party software or license.
+
+
+1.1.7. Reservation of Rights
+
+NVIDIA reserves all rights, title, and interest in and to the
+SDK, not expressly granted to you under this Agreement.
+
+
+1.2. Limitations
+
+The following license limitations apply to your use of the
+SDK:
+
+  1. You may not reverse engineer, decompile or disassemble,
+    or remove copyright or other proprietary notices from any
+    portion of the SDK or copies of the SDK.
+
+  2. Except as expressly provided in this Agreement, you may
+    not copy, sell, rent, sublicense, transfer, distribute,
+    modify, or create derivative works of any portion of the
+    SDK. For clarity, you may not distribute or sublicense the
+    SDK as a stand-alone product.
+
+  3. Unless you have an agreement with NVIDIA for this
+    purpose, you may not indicate that an application created
+    with the SDK is sponsored or endorsed by NVIDIA.
+
+  4. You may not bypass, disable, or circumvent any
+    encryption, security, digital rights management or
+    authentication mechanism in the SDK.
+
+  5. You may not use the SDK in any manner that would cause it
+    to become subject to an open source software license. As
+    examples, licenses that require as a condition of use,
+    modification, and/or distribution that the SDK be:
+
+      a. Disclosed or distributed in source code form;
+
+      b. Licensed for the purpose of making derivative works;
+        or
+
+      c. Redistributable at no charge.
+
+  6. Unless you have an agreement with NVIDIA for this
+    purpose, you may not use the SDK with any system or
+    application where the use or failure of the system or
+    application can reasonably be expected to threaten or
+    result in personal injury, death, or catastrophic loss.
+    Examples include use in avionics, navigation, military,
+    medical, life support or other life critical applications.
+    NVIDIA does not design, test or manufacture the SDK for
+    these critical uses and NVIDIA shall not be liable to you
+    or any third party, in whole or in part, for any claims or
+    damages arising from such uses.
+
+  7. You agree to defend, indemnify and hold harmless NVIDIA
+    and its affiliates, and their respective employees,
+    contractors, agents, officers and directors, from and
+    against any and all claims, damages, obligations, losses,
+    liabilities, costs or debt, fines, restitutions and
+    expenses (including but not limited to attorney’s fees
+    and costs incident to establishing the right of
+    indemnification) arising out of or related to your use of
+    the SDK outside of the scope of this Agreement, or not in
+    compliance with its terms.
+
+
+1.3. Ownership
+
+  1.  NVIDIA or its licensors hold all rights, title and
+    interest in and to the SDK and its modifications and
+    derivative works, including their respective intellectual
+    property rights, subject to your rights described in this
+    section. This SDK may include software and materials from
+    NVIDIA’s licensors, and these licensors are intended
+    third party beneficiaries that may enforce this Agreement
+    with respect to their intellectual property rights.
+
+  2.  You hold all rights, title and interest in and to your
+    applications and your derivative works of the sample
+    source code delivered in the SDK, including their
+    respective intellectual property rights, subject to
+    NVIDIA’s rights described in this section.
+
+  3. You may, but don’t have to, provide to NVIDIA
+    suggestions, feature requests or other feedback regarding
+    the SDK, including possible enhancements or modifications
+    to the SDK. For any feedback that you voluntarily provide,
+    you hereby grant NVIDIA and its affiliates a perpetual,
+    non-exclusive, worldwide, irrevocable license to use,
+    reproduce, modify, license, sublicense (through multiple
+    tiers of sublicensees), and distribute (through multiple
+    tiers of distributors) it without the payment of any
+    royalties or fees to you. NVIDIA will use feedback at its
+    choice. NVIDIA is constantly looking for ways to improve
+    its products, so you may send feedback to NVIDIA through
+    the developer portal at https://developer.nvidia.com.
+
+
+1.4. No Warranties
+
+THE SDK IS PROVIDED BY NVIDIA “AS IS” AND “WITH ALL
+FAULTS.” TO THE MAXIMUM EXTENT PERMITTED BY LAW, NVIDIA AND
+ITS AFFILIATES EXPRESSLY DISCLAIM ALL WARRANTIES OF ANY KIND
+OR NATURE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING,
+BUT NOT LIMITED TO, ANY WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE, TITLE, NON-INFRINGEMENT, OR THE
+ABSENCE OF ANY DEFECTS THEREIN, WHETHER LATENT OR PATENT. NO
+WARRANTY IS MADE ON THE BASIS OF TRADE USAGE, COURSE OF
+DEALING OR COURSE OF TRADE.
+
+
+1.5. Limitation of Liability
+
+TO THE MAXIMUM EXTENT PERMITTED BY LAW, NVIDIA AND ITS
+AFFILIATES SHALL NOT BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
+PUNITIVE OR CONSEQUENTIAL DAMAGES, OR ANY LOST PROFITS, LOSS
+OF USE, LOSS OF DATA OR LOSS OF GOODWILL, OR THE COSTS OF
+PROCURING SUBSTITUTE PRODUCTS, ARISING OUT OF OR IN CONNECTION
+WITH THIS AGREEMENT OR THE USE OR PERFORMANCE OF THE SDK,
+WHETHER SUCH LIABILITY ARISES FROM ANY CLAIM BASED UPON BREACH
+OF CONTRACT, BREACH OF WARRANTY, TORT (INCLUDING NEGLIGENCE),
+PRODUCT LIABILITY OR ANY OTHER CAUSE OF ACTION OR THEORY OF
+LIABILITY. IN NO EVENT WILL NVIDIA’S AND ITS AFFILIATES
+TOTAL CUMULATIVE LIABILITY UNDER OR ARISING OUT OF THIS
+AGREEMENT EXCEED US$10.00. THE NATURE OF THE LIABILITY OR THE
+NUMBER OF CLAIMS OR SUITS SHALL NOT ENLARGE OR EXTEND THIS
+LIMIT.
+
+These exclusions and limitations of liability shall apply
+regardless if NVIDIA or its affiliates have been advised of
+the possibility of such damages, and regardless of whether a
+remedy fails its essential purpose. These exclusions and
+limitations of liability form an essential basis of the
+bargain between the parties, and, absent any of these
+exclusions or limitations of liability, the provisions of this
+Agreement, including, without limitation, the economic terms,
+would be substantially different.
+
+
+1.6. Termination
+
+  1. This Agreement will continue to apply until terminated by
+    either you or NVIDIA as described below.
+
+  2. If you want to terminate this Agreement, you may do so by
+    stopping to use the SDK.
+
+  3. NVIDIA may, at any time, terminate this Agreement if:
+
+      a. (i) you fail to comply with any term of this
+        Agreement and the non-compliance is not fixed within
+        thirty (30) days following notice from NVIDIA (or
+        immediately if you violate NVIDIA’s intellectual
+        property rights);
+
+      b. (ii) you commence or participate in any legal
+        proceeding against NVIDIA with respect to the SDK; or
+
+      c. (iii) NVIDIA decides to no longer provide the SDK in
+        a country or, in NVIDIA’s sole discretion, the
+        continued use of it is no longer commercially viable.
+
+  4. Upon any termination of this Agreement, you agree to
+    promptly discontinue use of the SDK and destroy all copies
+    in your possession or control. Your prior distributions in
+    accordance with this Agreement are not affected by the
+    termination of this Agreement. Upon written request, you
+    will certify in writing that you have complied with your
+    commitments under this section. Upon any termination of
+    this Agreement all provisions survive except for the
+    license grant provisions.
+
+
+1.7. General
+
+If you wish to assign this Agreement or your rights and
+obligations, including by merger, consolidation, dissolution
+or operation of law, contact NVIDIA to ask for permission. Any
+attempted assignment not approved by NVIDIA in writing shall
+be void and of no effect. NVIDIA may assign, delegate or
+transfer this Agreement and its rights and obligations, and if
+to a non-affiliate you will be notified.
+
+You agree to cooperate with NVIDIA and provide reasonably
+requested information to verify your compliance with this
+Agreement.
+
+This Agreement will be governed in all respects by the laws of
+the United States and of the State of Delaware as those laws
+are applied to contracts entered into and performed entirely
+within Delaware by Delaware residents, without regard to the
+conflicts of laws principles. The United Nations Convention on
+Contracts for the International Sale of Goods is specifically
+disclaimed. You agree to all terms of this Agreement in the
+English language.
+
+The state or federal courts residing in Santa Clara County,
+California shall have exclusive jurisdiction over any dispute
+or claim arising out of this Agreement. Notwithstanding this,
+you agree that NVIDIA shall still be allowed to apply for
+injunctive remedies or an equivalent type of urgent legal
+relief in any jurisdiction.
+
+If any court of competent jurisdiction determines that any
+provision of this Agreement is illegal, invalid or
+unenforceable, such provision will be construed as limited to
+the extent necessary to be consistent with and fully
+enforceable under the law and the remaining provisions will
+remain in full force and effect. Unless otherwise specified,
+remedies are cumulative.
+
+Each party acknowledges and agrees that the other is an
+independent contractor in the performance of this Agreement.
+
+The SDK has been developed entirely at private expense and is
+“commercial items” consisting of “commercial computer
+software” and “commercial computer software
+documentation” provided with RESTRICTED RIGHTS. Use,
+duplication or disclosure by the U.S. Government or a U.S.
+Government subcontractor is subject to the restrictions in
+this Agreement pursuant to DFARS 227.7202-3(a) or as set forth
+in subparagraphs (c)(1) and (2) of the Commercial Computer
+Software - Restricted Rights clause at FAR 52.227-19, as
+applicable. Contractor/manufacturer is NVIDIA, 2788 San Tomas
+Expressway, Santa Clara, CA 95051.
+
+The SDK is subject to United States export laws and
+regulations. You agree that you will not ship, transfer or
+export the SDK into any country, or use the SDK in any manner,
+prohibited by the United States Bureau of Industry and
+Security or economic sanctions regulations administered by the
+U.S. Department of Treasury’s Office of Foreign Assets
+Control (OFAC), or any applicable export laws, restrictions or
+regulations. These laws include restrictions on destinations,
+end users and end use. By accepting this Agreement, you
+confirm that you are not a resident or citizen of any country
+currently embargoed by the U.S. and that you are not otherwise
+prohibited from receiving the SDK.
+
+Any notice delivered by NVIDIA to you under this Agreement
+will be delivered via mail, email or fax. You agree that any
+notices that NVIDIA sends you electronically will satisfy any
+legal communication requirements. Please direct your legal
+notices or other correspondence to NVIDIA Corporation, 2788
+San Tomas Expressway, Santa Clara, California 95051, United
+States of America, Attention: Legal Department.
+
+This Agreement and any exhibits incorporated into this
+Agreement constitute the entire agreement of the parties with
+respect to the subject matter of this Agreement and supersede
+all prior negotiations or documentation exchanged between the
+parties relating to this SDK license. Any additional and/or
+conflicting terms on documents issued by you are null, void,
+and invalid. Any amendment or waiver under this Agreement
+shall be in writing and signed by representatives of both
+parties.
+
+
+2. CUDA Toolkit Supplement to Software License Agreement for
+NVIDIA Software Development Kits
+------------------------------------------------------------
+
+
+Release date: August 16, 2018
+-----------------------------
+
+The terms in this supplement govern your use of the NVIDIA
+CUDA Toolkit SDK under the terms of your license agreement
+(“Agreement”) as modified by this supplement. Capitalized
+terms used but not defined below have the meaning assigned to
+them in the Agreement.
+
+This supplement is an exhibit to the Agreement and is
+incorporated as an integral part of the Agreement. In the
+event of conflict between the terms in this supplement and the
+terms in the Agreement, the terms in this supplement govern.
+
+
+2.1. License Scope
+
+The SDK is licensed for you to develop applications only for
+use in systems with NVIDIA GPUs.
+
+
+2.2. Distribution
+
+The portions of the SDK that are distributable under the
+Agreement are listed in Attachment A.
+
+
+2.3. Operating Systems
+
+Those portions of the SDK designed exclusively for use on the
+Linux or FreeBSD operating systems, or other operating systems
+derived from the source code to these operating systems, may
+be copied and redistributed for use in accordance with this
+Agreement, provided that the object code files are not
+modified in any way (except for unzipping of compressed
+files).
+
+
+2.4. Audio and Video Encoders and Decoders
+
+You acknowledge and agree that it is your sole responsibility
+to obtain any additional third-party licenses required to
+make, have made, use, have used, sell, import, and offer for
+sale your products or services that include or incorporate any
+third-party software and content relating to audio and/or
+video encoders and decoders from, including but not limited
+to, Microsoft, Thomson, Fraunhofer IIS, Sisvel S.p.A.,
+MPEG-LA, and Coding Technologies. NVIDIA does not grant to you
+under this Agreement any necessary patent or other rights with
+respect to any audio and/or video encoders and decoders.
+
+
+2.5. Licensing
+
+If the distribution terms in this Agreement are not suitable
+for your organization, or for any questions regarding this
+Agreement, please contact NVIDIA at
+[email protected].
+
+
+2.6. Attachment A
+
+The following portions of the SDK are distributable under the
+Agreement:
+
+Component
+
+CUDA Runtime
+
+Windows
+
+cudart.dll, cudart_static.lib, cudadevrt.lib
+
+Mac OSX
+
+libcudart.dylib, libcudart_static.a, libcudadevrt.a
+
+Linux
+
+libcudart.so, libcudart_static.a, libcudadevrt.a
+
+Android
+
+libcudart.so, libcudart_static.a, libcudadevrt.a
+
+Component
+
+CUDA FFT Library
+
+Windows
+
+cufft.dll, cufftw.dll, cufft.lib, cufftw.lib
+
+Mac OSX
+
+libcufft.dylib, libcufft_static.a, libcufftw.dylib,
+libcufftw_static.a
+
+Linux
+
+libcufft.so, libcufft_static.a, libcufftw.so,
+libcufftw_static.a
+
+Android
+
+libcufft.so, libcufft_static.a, libcufftw.so,
+libcufftw_static.a
+
+Component
+
+CUDA BLAS Library
+
+Windows
+
+cublas.dll, cublasLt.dll
+
+Mac OSX
+
+libcublas.dylib, libcublasLt.dylib, libcublas_static.a,
+libcublasLt_static.a
+
+Linux
+
+libcublas.so, libcublasLt.so, libcublas_static.a,
+libcublasLt_static.a
+
+Android
+
+libcublas.so, libcublasLt.so, libcublas_static.a,
+libcublasLt_static.a
+
+Component
+
+NVIDIA "Drop-in" BLAS Library
+
+Windows
+
+nvblas.dll
+
+Mac OSX
+
+libnvblas.dylib
+
+Linux
+
+libnvblas.so
+
+Component
+
+CUDA Sparse Matrix Library
+
+Windows
+
+cusparse.dll, cusparse.lib
+
+Mac OSX
+
+libcusparse.dylib, libcusparse_static.a
+
+Linux
+
+libcusparse.so, libcusparse_static.a
+
+Android
+
+libcusparse.so, libcusparse_static.a
+
+Component
+
+CUDA Linear Solver Library
+
+Windows
+
+cusolver.dll, cusolver.lib
+
+Mac OSX
+
+libcusolver.dylib, libcusolver_static.a
+
+Linux
+
+libcusolver.so, libcusolver_static.a
+
+Android
+
+libcusolver.so, libcusolver_static.a
+
+Component
+
+CUDA Random Number Generation Library
+
+Windows
+
+curand.dll, curand.lib
+
+Mac OSX
+
+libcurand.dylib, libcurand_static.a
+
+Linux
+
+libcurand.so, libcurand_static.a
+
+Android
+
+libcurand.so, libcurand_static.a
+
+Component
+
+CUDA Accelerated Graph Library
+
+Component
+
+NVIDIA Performance Primitives Library
+
+Windows
+
+nppc.dll, nppc.lib, nppial.dll, nppial.lib, nppicc.dll,
+nppicc.lib, nppicom.dll, nppicom.lib, nppidei.dll,
+nppidei.lib, nppif.dll, nppif.lib, nppig.dll, nppig.lib,
+nppim.dll, nppim.lib, nppist.dll, nppist.lib, nppisu.dll,
+nppisu.lib, nppitc.dll, nppitc.lib, npps.dll, npps.lib
+
+Mac OSX
+
+libnppc.dylib, libnppc_static.a, libnppial.dylib,
+libnppial_static.a, libnppicc.dylib, libnppicc_static.a,
+libnppicom.dylib, libnppicom_static.a, libnppidei.dylib,
+libnppidei_static.a, libnppif.dylib, libnppif_static.a,
+libnppig.dylib, libnppig_static.a, libnppim.dylib,
+libnppisu_static.a, libnppitc.dylib, libnppitc_static.a,
+libnpps.dylib, libnpps_static.a
+
+Linux
+
+libnppc.so, libnppc_static.a, libnppial.so,
+libnppial_static.a, libnppicc.so, libnppicc_static.a,
+libnppicom.so, libnppicom_static.a, libnppidei.so,
+libnppidei_static.a, libnppif.so, libnppif_static.a
+libnppig.so, libnppig_static.a, libnppim.so,
+libnppim_static.a, libnppist.so, libnppist_static.a,
+libnppisu.so, libnppisu_static.a, libnppitc.so
+libnppitc_static.a, libnpps.so, libnpps_static.a
+
+Android
+
+libnppc.so, libnppc_static.a, libnppial.so,
+libnppial_static.a, libnppicc.so, libnppicc_static.a,
+libnppicom.so, libnppicom_static.a, libnppidei.so,
+libnppidei_static.a, libnppif.so, libnppif_static.a
+libnppig.so, libnppig_static.a, libnppim.so,
+libnppim_static.a, libnppist.so, libnppist_static.a,
+libnppisu.so, libnppisu_static.a, libnppitc.so
+libnppitc_static.a, libnpps.so, libnpps_static.a
+
+Component
+
+NVIDIA JPEG Library
+
+Linux
+
+libnvjpeg.so, libnvjpeg_static.a
+
+Component
+
+Internal common library required for statically linking to
+cuBLAS, cuSPARSE, cuFFT, cuRAND, nvJPEG and NPP
+
+Mac OSX
+
+libculibos.a
+
+Linux
+
+libculibos.a
+
+Component
+
+NVIDIA Runtime Compilation Library and Header
+
+All
+
+nvrtc.h
+
+Windows
+
+nvrtc.dll, nvrtc-builtins.dll
+
+Mac OSX
+
+libnvrtc.dylib, libnvrtc-builtins.dylib
+
+Linux
+
+libnvrtc.so, libnvrtc-builtins.so
+
+Component
+
+NVIDIA Optimizing Compiler Library
+
+Windows
+
+nvvm.dll
+
+Mac OSX
+
+libnvvm.dylib
+
+Linux
+
+libnvvm.so
+
+Component
+
+NVIDIA Common Device Math Functions Library
+
+Windows
+
+libdevice.10.bc
+
+Mac OSX
+
+libdevice.10.bc
+
+Linux
+
+libdevice.10.bc
+
+Component
+
+CUDA Occupancy Calculation Header Library
+
+All
+
+cuda_occupancy.h
+
+Component
+
+CUDA Half Precision Headers
+
+All
+
+cuda_fp16.h, cuda_fp16.hpp
+
+Component
+
+CUDA Profiling Tools Interface (CUPTI) Library
+
+Windows
+
+cupti.dll
+
+Mac OSX
+
+libcupti.dylib
+
+Linux
+
+libcupti.so
+
+Component
+
+NVIDIA Tools Extension Library
+
+Windows
+
+nvToolsExt.dll, nvToolsExt.lib
+
+Mac OSX
+
+libnvToolsExt.dylib
+
+Linux
+
+libnvToolsExt.so
+
+Component
+
+NVIDIA CUDA Driver Libraries
+
+Linux
+
+libcuda.so, libnvidia-fatbinaryloader.so,
+libnvidia-ptxjitcompiler.so
+
+The NVIDIA CUDA Driver Libraries are only distributable in
+applications that meet this criteria:
+
+  1. The application was developed starting from a NVIDIA CUDA
+    container obtained from Docker Hub or the NVIDIA GPU
+    Cloud, and
+
+  2. The resulting application is packaged as a Docker
+    container and distributed to users on Docker Hub or the
+    NVIDIA GPU Cloud only.
+
+
+2.7. Attachment B
+
+
+Additional Licensing Obligations
+
+The following third party components included in the SOFTWARE
+are licensed to Licensee pursuant to the following terms and
+conditions:
+
+  1. Licensee's use of the GDB third party component is
+    subject to the terms and conditions of GNU GPL v3:
+
+    This product includes copyrighted third-party software licensed
+    under the terms of the GNU General Public License v3 ("GPL v3").
+    All third-party software packages are copyright by their respective
+    authors. GPL v3 terms and conditions are hereby incorporated into
+    the Agreement by this reference:     http://www.gnu.org/licenses/gpl.txt
+
+    Consistent with these licensing requirements, the software
+    listed below is provided under the terms of the specified
+    open source software licenses. To obtain source code for
+    software provided under licenses that require
+    redistribution of source code, including the GNU General
+    Public License (GPL) and GNU Lesser General Public License
+    (LGPL), contact [email protected]. This offer is
+    valid for a period of three (3) years from the date of the
+    distribution of this product by NVIDIA CORPORATION.
+
+    Component          License
+    CUDA-GDB           GPL v3
+
+  2. Licensee represents and warrants that any and all third
+    party licensing and/or royalty payment obligations in
+    connection with Licensee's use of the H.264 video codecs
+    are solely the responsibility of Licensee.
+
+  3. Licensee's use of the Thrust library is subject to the
+    terms and conditions of the Apache License Version 2.0.
+    All third-party software packages are copyright by their
+    respective authors. Apache License Version 2.0 terms and
+    conditions are hereby incorporated into the Agreement by
+    this reference.
+    http://www.apache.org/licenses/LICENSE-2.0.html
+
+    In addition, Licensee acknowledges the following notice:
+    Thrust includes source code from the Boost Iterator,
+    Tuple, System, and Random Number libraries.
+
+    Boost Software License - Version 1.0 - August 17th, 2003
+    . . . .
+
+    Permission is hereby granted, free of charge, to any person or
+    organization obtaining a copy of the software and accompanying
+    documentation covered by this license (the "Software") to use,
+    reproduce, display, distribute, execute, and transmit the Software,
+    and to prepare derivative works of the Software, and to permit
+    third-parties to whom the Software is furnished to do so, all
+    subject to the following:
+
+    The copyright notices in the Software and this entire statement,
+    including the above license grant, this restriction and the following
+    disclaimer, must be included in all copies of the Software, in whole
+    or in part, and all derivative works of the Software, unless such
+    copies or derivative works are solely in the form of machine-executable
+    object code generated by a source language processor.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
+    NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
+    ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR
+    OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+    OTHER DEALINGS IN THE SOFTWARE.
+
+  4. Licensee's use of the LLVM third party component is
+    subject to the following terms and conditions:
+
+    ======================================================
+    LLVM Release License
+    ======================================================
+    University of Illinois/NCSA
+    Open Source License
+
+    Copyright (c) 2003-2010 University of Illinois at Urbana-Champaign.
+    All rights reserved.
+
+    Developed by:
+
+        LLVM Team
+
+        University of Illinois at Urbana-Champaign
+
+        http://llvm.org
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to
+    deal with the Software without restriction, including without limitation the
+    rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+    sell copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    *  Redistributions of source code must retain the above copyright notice,
+       this list of conditions and the following disclaimers.
+
+    *  Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimers in the
+       documentation and/or other materials provided with the distribution.
+
+    *  Neither the names of the LLVM Team, University of Illinois at Urbana-
+       Champaign, nor the names of its contributors may be used to endorse or
+       promote products derived from this Software without specific prior
+       written permission.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+    THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+    OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+    ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+    DEALINGS WITH THE SOFTWARE.
+
+  5. Licensee's use (e.g. nvprof) of the PCRE third party
+    component is subject to the following terms and
+    conditions:
+
+    ------------
+    PCRE LICENCE
+    ------------
+    PCRE is a library of functions to support regular expressions whose syntax
+    and semantics are as close as possible to those of the Perl 5 language.
+    Release 8 of PCRE is distributed under the terms of the "BSD" licence, as
+    specified below. The documentation for PCRE, supplied in the "doc"
+    directory, is distributed under the same terms as the software itself. The
+    basic library functions are written in C and are freestanding. Also
+    included in the distribution is a set of C++ wrapper functions, and a just-
+    in-time compiler that can be used to optimize pattern matching. These are
+    both optional features that can be omitted when the library is built.
+
+    THE BASIC LIBRARY FUNCTIONS
+    ---------------------------
+    Written by:       Philip Hazel
+    Email local part: ph10
+    Email domain:     cam.ac.uk
+    University of Cambridge Computing Service,
+    Cambridge, England.
+    Copyright (c) 1997-2012 University of Cambridge
+    All rights reserved.
+
+    PCRE JUST-IN-TIME COMPILATION SUPPORT
+    -------------------------------------
+    Written by:       Zoltan Herczeg
+    Email local part: hzmester
+    Emain domain:     freemail.hu
+    Copyright(c) 2010-2012 Zoltan Herczeg
+    All rights reserved.
+
+    STACK-LESS JUST-IN-TIME COMPILER
+    --------------------------------
+    Written by:       Zoltan Herczeg
+    Email local part: hzmester
+    Emain domain:     freemail.hu
+    Copyright(c) 2009-2012 Zoltan Herczeg
+    All rights reserved.
+
+    THE C++ WRAPPER FUNCTIONS
+    -------------------------
+    Contributed by:   Google Inc.
+    Copyright (c) 2007-2012, Google Inc.
+    All rights reserved.
+
+    THE "BSD" LICENCE
+    -----------------
+    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 name of the University of Cambridge nor the name of Google
+        Inc. nor the names of their 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.
+
+  6. Some of the cuBLAS library routines were written by or
+    derived from code written by Vasily Volkov and are subject
+    to the Modified Berkeley Software Distribution License as
+    follows:
+
+    Copyright (c) 2007-2009, Regents of the University of California
+
+    All rights reserved.
+
+    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 name of the University of California, Berkeley nor
+          the names of its contributors may be used to endorse or promote
+          products derived from this software without specific prior
+          written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE AUTHOR "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 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.
+
+  7. Some of the cuBLAS library routines were written by or
+    derived from code written by Davide Barbieri and are
+    subject to the Modified Berkeley Software Distribution
+    License as follows:
+
+    Copyright (c) 2008-2009 Davide Barbieri @ University of Rome Tor Vergata.
+
+    All rights reserved.
+
+    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.
+        * The name of the author may not be used to endorse or promote
+          products derived from this software without specific prior
+          written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE AUTHOR "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 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.
+
+  8. Some of the cuBLAS library routines were derived from
+    code developed by the University of Tennessee and are
+    subject to the Modified Berkeley Software Distribution
+    License as follows:
+
+    Copyright (c) 2010 The University of Tennessee.
+
+    All rights reserved.
+
+    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 listed in this license in the documentation and/or
+          other materials provided with the distribution.
+        * Neither the name of the copyright holders nor the names of its
+          contributors may be used to endorse or promote products derived
+          from this software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    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.
+
+  9. Some of the cuBLAS library routines were written by or
+    derived from code written by Jonathan Hogg and are subject
+    to the Modified Berkeley Software Distribution License as
+    follows:
+
+    Copyright (c) 2012, The Science and Technology Facilities Council (STFC).
+
+    All rights reserved.
+
+    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 name of the STFC nor the names of its contributors
+          may be used to endorse or promote products derived from this
+          software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE STFC 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.
+
+  10. Some of the cuBLAS library routines were written by or
+    derived from code written by Ahmad M. Abdelfattah, David
+    Keyes, and Hatem Ltaief, and are subject to the Apache
+    License, Version 2.0, as follows:
+
+     -- (C) Copyright 2013 King Abdullah University of Science and Technology
+      Authors:
+      Ahmad Abdelfattah ([email protected])
+      David Keyes ([email protected])
+      Hatem Ltaief ([email protected])
+
+      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  name of the King Abdullah University of Science and
+        Technology nor the names of its contributors may be used to endorse
+        or promote products derived from this software without specific prior
+        written permission.
+
+      THIS  SOFTWARE  IS  PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+      ``AS IS''  AND  ANY  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+      LIMITED  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+      A  PARTICULAR  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+      HOLDERS 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
+
+  11. Some of the cuSPARSE library routines were written by or
+    derived from code written by Li-Wen Chang and are subject
+    to the NCSA Open Source License as follows:
+
+    Copyright (c) 2012, University of Illinois.
+
+    All rights reserved.
+
+    Developed by: IMPACT Group, University of Illinois, http://impact.crhc.illinois.edu
+
+    Permission is hereby granted, free of charge, to any person obtaining
+    a copy of this software and associated documentation files (the
+    "Software"), to deal with the Software without restriction, including
+    without limitation the rights to use, copy, modify, merge, publish,
+    distribute, sublicense, and/or sell copies of the Software, and to
+    permit persons to whom the Software is furnished to do so, subject to
+    the following conditions:
+        * 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
+          disclaimers in the documentation and/or other materials provided
+          with the distribution.
+        * Neither the names of IMPACT Group, University of Illinois, nor
+          the names of its contributors may be used to endorse or promote
+          products derived from this Software without specific prior
+          written permission.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    NONINFRINGEMENT. IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT
+    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+    IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+    IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
+    SOFTWARE.
+
+  12. Some of the cuRAND library routines were written by or
+    derived from code written by Mutsuo Saito and Makoto
+    Matsumoto and are subject to the following license:
+
+    Copyright (c) 2009, 2010 Mutsuo Saito, Makoto Matsumoto and Hiroshima
+    University. All rights reserved.
+
+    Copyright (c) 2011 Mutsuo Saito, Makoto Matsumoto, Hiroshima
+    University and University of Tokyo.  All rights reserved.
+
+    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 name of the Hiroshima University nor the names of
+          its contributors may be used to endorse or promote products
+          derived from this software without specific prior written
+          permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    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.
+
+  13. Some of the cuRAND library routines were derived from
+    code developed by D. E. Shaw Research and are subject to
+    the following license:
+
+    Copyright 2010-2011, D. E. Shaw Research.
+
+    All rights reserved.
+
+    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 name of D. E. Shaw Research nor the names of its
+          contributors may be used to endorse or promote products derived
+          from this software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    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.
+
+  14. Some of the Math library routines were written by or
+    derived from code developed by Norbert Juffa and are
+    subject to the following license:
+
+    Copyright (c) 2015-2017, Norbert Juffa
+    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.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+  15. Licensee's use of the lz4 third party component is
+    subject to the following terms and conditions:
+
+    Copyright (C) 2011-2013, Yann Collet.
+    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+    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.
+
+    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.
+
+  16. The NPP library uses code from the Boost Math Toolkit,
+    and is subject to the following license:
+
+    Boost Software License - Version 1.0 - August 17th, 2003
+    . . . .
+
+    Permission is hereby granted, free of charge, to any person or
+    organization obtaining a copy of the software and accompanying
+    documentation covered by this license (the "Software") to use,
+    reproduce, display, distribute, execute, and transmit the Software,
+    and to prepare derivative works of the Software, and to permit
+    third-parties to whom the Software is furnished to do so, all
+    subject to the following:
+
+    The copyright notices in the Software and this entire statement,
+    including the above license grant, this restriction and the following
+    disclaimer, must be included in all copies of the Software, in whole
+    or in part, and all derivative works of the Software, unless such
+    copies or derivative works are solely in the form of machine-executable
+    object code generated by a source language processor.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
+    NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
+    ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR
+    OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+    OTHER DEALINGS IN THE SOFTWARE.
+
+  17. Portions of the Nsight Eclipse Edition is subject to the
+    following license:
+
+    The Eclipse Foundation makes available all content in this plug-in
+    ("Content"). Unless otherwise indicated below, the Content is provided
+    to you under the terms and conditions of the Eclipse Public License
+    Version 1.0 ("EPL"). A copy of the EPL is available at http://
+    www.eclipse.org/legal/epl-v10.html. For purposes of the EPL, "Program"
+    will mean the Content.
+
+    If you did not receive this Content directly from the Eclipse
+    Foundation, the Content is being redistributed by another party
+    ("Redistributor") and different terms and conditions may apply to your
+    use of any object code in the Content. Check the Redistributor's
+    license that was provided with the Content. If no such license exists,
+    contact the Redistributor. Unless otherwise indicated below, the terms
+    and conditions of the EPL still apply to any source code in the
+    Content and such source code may be obtained at http://www.eclipse.org.
+
+  18. Some of the cuBLAS library routines uses code from
+    OpenAI, which is subject to the following license:
+
+    License URL
+    https://github.com/openai/openai-gemm/blob/master/LICENSE
+
+    License Text
+    The MIT License
+
+    Copyright (c) 2016 OpenAI (http://openai.com), 2016 Google Inc.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in
+    all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+    THE SOFTWARE.
+
+  19. Licensee's use of the Visual Studio Setup Configuration
+    Samples is subject to the following license:
+
+    The MIT License (MIT)
+    Copyright (C) Microsoft Corporation. All rights reserved.
+
+    Permission is hereby granted, free of charge, to any person
+    obtaining a copy of this software and associated documentation
+    files (the "Software"), to deal in the Software without restriction,
+    including without limitation the rights to use, copy, modify, merge,
+    publish, distribute, sublicense, and/or sell copies of the Software,
+    and to permit persons to whom the Software is furnished to do so,
+    subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included
+    in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+  20. Licensee's use of linmath.h header for CPU functions for
+    GL vector/matrix operations from lunarG is subject to the
+    Apache License Version 2.0.
+
+  21. The DX12-CUDA sample uses the d3dx12.h header, which is
+    subject to the MIT license .
+
+-----------------

llmeval-env/lib/python3.10/site-packages/nvidia_cuda_runtime_cu12-12.1.105.dist-info/METADATA

@@ -0,0 +1,35 @@
+Metadata-Version: 2.1
+Name: nvidia-cuda-runtime-cu12
+Version: 12.1.105
+Summary: CUDA Runtime native Libraries
+Home-page: https://developer.nvidia.com/cuda-zone
+Author: Nvidia CUDA Installer Team
+Author-email: [email protected]
+License: NVIDIA Proprietary Software
+Keywords: cuda,nvidia,runtime,machine learning,deep learning
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: Other/Proprietary License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+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 :: Only
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3
+License-File: License.txt
+
+CUDA Runtime native Libraries