perpetual 0.7.11__cp313-cp313-macosx_11_0_arm64.whl

perpetual/data.py

@@ -0,0 +1,24 @@
+from dataclasses import dataclass
+from typing import Iterable, Optional, Union
+
+
+@dataclass
+class Node:
+    """Dataclass representation of a node, this represents all of the fields present in a tree node."""
+
+    num: int
+    weight_value: float
+    hessian_sum: float
+    depth: int
+    split_value: float
+    split_feature: Union[str, int]
+    split_gain: float
+    missing_node: int
+    left_child: int
+    right_child: int
+    is_leaf: bool
+    node_type: str
+    parent_node: int
+    generalization: Optional[float]
+    left_cats: Optional[Iterable]
+    right_cats: Optional[Iterable]

perpetual/serialize.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import json
+from abc import ABC, abstractmethod
+from ast import literal_eval
+from dataclasses import dataclass
+from typing import Dict, Generic, List, Tuple, TypeVar, Union
+
+import numpy as np
+import numpy.typing as npt
+
+T = TypeVar("T")
+
+
+class BaseSerializer(ABC, Generic[T]):
+    @abstractmethod
+    def serialize(self, obj: T) -> str:
+        """serialize method - should take an object and return a string"""
+
+    @abstractmethod
+    def deserialize(self, obj_repr: str) -> T:
+        """deserialize method - should take a string and return original object"""
+
+
+Scaler = Union[int, float, str]
+
+
+class ScalerSerializer(BaseSerializer[Scaler]):
+    def serialize(self, obj: Scaler) -> str:
+        if isinstance(obj, str):
+            obj_ = f"'{obj}'"
+        else:
+            obj_ = str(obj)
+        return obj_
+
+    def deserialize(self, obj_repr: str) -> Scaler:
+        return literal_eval(node_or_string=obj_repr)
+
+
+ObjectItem = Union[
+    List[Scaler],
+    Dict[str, Scaler],
+    Scaler,
+]
+
+
+class ObjectSerializer(BaseSerializer[ObjectItem]):
+    def serialize(self, obj: ObjectItem) -> str:
+        return json.dumps(obj)
+
+    def deserialize(self, obj_repr: str) -> ObjectItem:
+        return json.loads(obj_repr)
+
+
+@dataclass
+class NumpyData:
+    array: Union[List[float], List[int]]
+    dtype: str
+    shape: Tuple[int, ...]
+
+
+class NumpySerializer(BaseSerializer[npt.NDArray]):
+    def serialize(self, obj: npt.NDArray) -> str:
+        return json.dumps(
+            {"array": obj.tolist(), "dtype": str(obj.dtype), "shape": obj.shape}
+        )
+
+    def deserialize(self, obj_repr: str) -> npt.NDArray:
+        data = NumpyData(**json.loads(obj_repr))
+        a = np.array(data.array, dtype=data.dtype)  # type: ignore
+        if len(data.shape) == 1:
+            return a
+        else:
+            return a.reshape(data.shape)

perpetual/types.py

@@ -0,0 +1,150 @@
+import numpy as np
+from typing_extensions import Self
+from typing import Any, Dict, Iterable, Protocol, Set
+
+
+class BoosterType(Protocol):
+    monotone_constraints: Dict[int, int]
+    terminate_missing_features: Set[int]
+    number_of_trees: int
+    base_score: float
+
+    def fit(
+        self,
+        flat_data: np.ndarray,
+        rows: int,
+        cols: int,
+        y: np.ndarray,
+        budget: float,
+        sample_weight: np.ndarray,
+        parallel: bool = False,
+    ):
+        """Fit method"""
+
+    def predict(
+        self,
+        flat_data: np.ndarray,
+        rows: int,
+        cols: int,
+        parallel: bool = True,
+    ) -> np.ndarray:
+        """predict method"""
+
+    def predict_proba(
+        self,
+        flat_data: np.ndarray,
+        rows: int,
+        cols: int,
+        parallel: bool = True,
+    ) -> np.ndarray:
+        """predict probabilities method"""
+
+    def predict_contributions(
+        self,
+        flat_data: np.ndarray,
+        rows: int,
+        cols: int,
+        method: str,
+        parallel: bool = True,
+    ) -> np.ndarray:
+        """method"""
+
+    def value_partial_dependence(
+        self,
+        feature: int,
+        value: float,
+    ) -> float:
+        """pass"""
+
+    def calculate_feature_importance(
+        self,
+        method: str,
+        normalize: bool,
+    ) -> Dict[int, float]:
+        """pass"""
+
+    def text_dump(self) -> Iterable[str]:
+        """pass"""
+
+    @classmethod
+    def load_booster(cls, path: str) -> Self:
+        """pass"""
+
+    def save_booster(self, path: str):
+        """pass"""
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """pass"""
+
+    def json_dump(self) -> str:
+        """pass"""
+
+    def get_params(self) -> Dict[str, Any]:
+        """pass"""
+
+    def insert_metadata(self, key: str, value: str) -> None:
+        """pass"""
+
+    def get_metadata(self, key: str) -> str:
+        """pass"""
+
+
+class MultiOutputBoosterType(Protocol):
+    monotone_constraints: Dict[int, int]
+    terminate_missing_features: Set[int]
+    number_of_trees: Iterable[int]
+    base_score: Iterable[float]
+
+    def fit(
+        self,
+        flat_data: np.ndarray,
+        rows: int,
+        cols: int,
+        y: np.ndarray,
+        budget: float,
+        sample_weight: np.ndarray,
+        parallel: bool = False,
+    ):
+        """Fit method"""
+
+    def predict(
+        self,
+        flat_data: np.ndarray,
+        rows: int,
+        cols: int,
+        parallel: bool = True,
+    ) -> np.ndarray:
+        """predict method"""
+
+    def predict_proba(
+        self,
+        flat_data: np.ndarray,
+        rows: int,
+        cols: int,
+        parallel: bool = True,
+    ) -> np.ndarray:
+        """predict probabilities method"""
+
+    @classmethod
+    def load_booster(cls, path: str) -> Self:
+        """pass"""
+
+    def save_booster(self, path: str):
+        """pass"""
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """pass"""
+
+    def json_dump(self) -> str:
+        """pass"""
+
+    def get_params(self) -> Dict[str, Any]:
+        """pass"""
+
+    def insert_metadata(self, key: str, value: str) -> None:
+        """pass"""
+
+    def get_metadata(self, key: str) -> str:
+        """pass"""

perpetual/utils.py

@@ -0,0 +1,215 @@
+import logging
+import numpy as np
+from typing import Dict, Iterable, List, Optional, Tuple
+
+
+logger = logging.getLogger(__name__)
+
+
+def type_df(df):
+    library_name = type(df).__module__.split(".")[0]
+    if type(df).__name__ == "DataFrame":
+        if library_name == "pandas":
+            return "pandas_df"
+        elif library_name == "polars":
+            return "polars_df"
+    elif library_name == "numpy":
+        return "numpy"
+    else:
+        return ""
+
+
+def type_series(y):
+    library_name = type(y).__module__.split(".")[0]
+    if type(y).__name__ == "Series":
+        if library_name == "pandas":
+            return "pandas_series"
+        elif library_name == "polars":
+            return "polars_series"
+    elif library_name == "numpy":
+        return "numpy"
+    else:
+        return ""
+
+
+def convert_input_array(x, objective) -> np.ndarray:
+    classes_ = []
+
+    if type(x).__module__.split(".")[0] == "numpy":
+        if len(x.shape) == 2:
+            classes_, x_, *_ = convert_input_frame(x, None, 1000)
+        else:
+            x_ = x
+    elif type_series(x) == "pandas_series":
+        x_ = x.to_numpy()
+    elif type_series(x) == "polars_series":
+        x_ = x.to_numpy(allow_copy=False)
+    elif type_df(x) == "polars_df" or type_df(x) == "pandas_df":
+        classes_, x_, *_ = convert_input_frame(x, None, 1000)
+    else:
+        x_ = x.to_numpy()
+
+    if objective == "LogLoss" and len(x_.shape) == 1:
+        classes_ = np.unique(x_)
+        x_index = np.array([np.where(classes_ == i) for i in x_])
+        if len(classes_) > 2:
+            x_ = np.squeeze(np.eye(len(classes_))[x_index])
+
+    if not np.issubdtype(x_.dtype, "float64"):
+        x_ = x_.astype(dtype="float64", copy=False)
+
+    if len(x_.shape) == 2:
+        x_ = x_.ravel(order="F")
+
+    return x_, classes_
+
+
+def convert_input_frame(
+    X, categorical_features, max_cat
+) -> Tuple[List[str], np.ndarray, int, int, Optional[Iterable[int]], Optional[Dict]]:
+    """Convert data to format needed by booster.
+
+    Returns:
+        Tuple[List[str], np.ndarray, int, int, Optional[Iterable[int]], Optional[Dict]]: Return column names, the flat data, number of rows, the number of columns, cat_index, cat_mapping
+    """
+    categorical_features_ = None
+    if type_df(X) == "pandas_df":
+        X_ = X.to_numpy()
+        features_ = X.columns.to_list()
+        if categorical_features == "auto":
+            categorical_columns = X.select_dtypes(include=["category"]).columns.tolist()
+            categorical_features_ = [
+                features_.index(c) for c in categorical_columns
+            ] or None
+    elif type_df(X) == "polars_df":
+        import polars.selectors as cs
+
+        try:
+            X_ = X.to_numpy(allow_copy=False)
+        except RuntimeError:
+            X_ = X.to_numpy(allow_copy=True)
+
+        features_ = X.columns
+        if categorical_features == "auto":
+            categorical_columns = X.select(cs.categorical()).columns
+            categorical_features_ = [
+                features_.index(c) for c in categorical_columns
+            ] or None
+    else:
+        # Assume it's a numpy array.
+        X_ = X
+        features_ = list(map(str, range(X_.shape[1])))
+
+    if (
+        categorical_features
+        and all(isinstance(s, int) for s in categorical_features)
+        and isinstance(categorical_features, list)
+    ):
+        categorical_features_ = categorical_features
+    elif (
+        categorical_features
+        and all(isinstance(s, str) for s in categorical_features)
+        and isinstance(categorical_features, list)
+    ):
+        categorical_features_ = [features_.index(c) for c in categorical_features]
+
+    cat_mapping = {}  # key: feature_name, value: ordered category names
+    cat_to_num = []
+    if categorical_features_:
+        for i in categorical_features_:
+            categories, inversed = np.unique(X_[:, i].astype(str), return_inverse=True)
+
+            categories = list(categories)
+            if "nan" in categories:
+                categories.remove("nan")
+            categories.insert(0, "nan")
+
+            inversed = inversed + 1.0
+
+            if len(categories) > max_cat:
+                cat_to_num.append(i)
+                logger.warning(
+                    f"Feature {features_[i]} will be treated as numerical since the number of categories ({len(categories)}) exceeds max_cat ({max_cat}) threshold."
+                )
+
+            feature_name = features_[i]
+            cat_mapping[feature_name] = categories
+            ind_nan = len(categories)
+            inversed[inversed == ind_nan] = np.nan
+            X_[:, i] = inversed
+
+        categorical_features_ = [
+            x for x in categorical_features_ if x not in cat_to_num
+        ]
+
+        logger.info(f"Categorical features: {categorical_features_}")
+        logger.info(f"Mapping of categories: {cat_mapping}")
+
+    if not np.issubdtype(X_.dtype, "float64"):
+        X_ = X_.astype(dtype="float64", copy=False)
+    flat_data = X_.ravel(order="F")
+    rows, cols = X_.shape
+
+    if isinstance(categorical_features_, list):
+        categorical_features_ = set(categorical_features_)
+
+    return features_, flat_data, rows, cols, categorical_features_, cat_mapping
+
+
+def transform_input_frame(X, cat_mapping) -> Tuple[List[str], np.ndarray, int, int]:
+    """Convert data to format needed by booster.
+
+    Returns:
+        Tuple[List[str], np.ndarray, int, int]: Return column names, the flat data, number of rows, the number of columns
+    """
+    if type_df(X) == "pandas_df":
+        X_ = X.to_numpy()
+        features_ = X.columns.to_list()
+    elif type_df(X) == "polars_df":
+        try:
+            X_ = X.to_numpy(allow_copy=False)
+        except RuntimeError:
+            X_ = X.to_numpy(allow_copy=True)
+        features_ = X.columns
+    else:
+        # Assume it's a numpy array.
+        X_ = X
+        features_ = list(map(str, range(X_.shape[1])))
+
+    if cat_mapping:
+        for feature_name, categories in cat_mapping.items():
+            feature_index = features_.index(feature_name)
+            cats = categories.copy()
+            cats.remove("nan")
+            x_enc = np.searchsorted(cats, X_[:, feature_index].astype(str))
+            x_enc = x_enc + 1.0
+            ind_nan = len(categories)
+            x_enc[x_enc == ind_nan] = np.nan
+            X_[:, feature_index] = x_enc
+
+    if not np.issubdtype(X_.dtype, "float64"):
+        X_ = X_.astype(dtype="float64", copy=False)
+    flat_data = X_.ravel(order="F")
+    rows, cols = X_.shape
+
+    return features_, flat_data, rows, cols
+
+
+CONTRIBUTION_METHODS = {
+    "weight": "Weight",
+    "Weight": "Weight",
+    "average": "Average",
+    "Average": "Average",
+    "branch-difference": "BranchDifference",
+    "branchdifference": "BranchDifference",
+    "BranchDifference": "BranchDifference",
+    "midpoint-difference": "MidpointDifference",
+    "midpointdifference": "MidpointDifference",
+    "MidpointDifference": "MidpointDifference",
+    "mode-difference": "ModeDifference",
+    "modedifference": "ModeDifference",
+    "ModeDifference": "ModeDifference",
+    "ProbabilityChange": "ProbabilityChange",
+    "probabilitychange": "ProbabilityChange",
+    "probability-change": "ProbabilityChange",
+}

perpetual-0.7.11.dist-info/METADATA

@@ -0,0 +1,134 @@
+Metadata-Version: 2.3
+Name: perpetual
+Version: 0.7.11
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: numpy
+Requires-Dist: typing-extensions
+Requires-Dist: pandas ; extra == 'dev'
+Requires-Dist: polars ; extra == 'dev'
+Requires-Dist: pyarrow ; extra == 'dev'
+Requires-Dist: maturin ==1.6.0 ; extra == 'dev'
+Requires-Dist: pytest ; extra == 'dev'
+Requires-Dist: seaborn ; extra == 'dev'
+Requires-Dist: scikit-learn ; extra == 'dev'
+Requires-Dist: mkdocs-material ; extra == 'dev'
+Requires-Dist: mkdocstrings[python] ; extra == 'dev'
+Requires-Dist: mkdocs-autorefs ; extra == 'dev'
+Requires-Dist: ruff ; extra == 'dev'
+Provides-Extra: dev
+License-File: LICENSE
+License-File: LICENSE
+Summary: A self-generalizing gradient boosting machine which doesn't need hyperparameter optimization
+Keywords: rust,perpetual,machine learning,tree model,decision tree,gradient boosted decision tree,gradient boosting machine
+Home-Page: https://perpetual-ml.com
+Author: Mutlu Simsek
+Author-email: Mutlu Simsek <msimsek@perpetual-ml.com>
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Source Code, https://github.com/perpetual-ml/perpetual
+
+<p align="center">
+  <img  height="120" src="https://github.com/perpetual-ml/perpetual/raw/main/resources/perp_logo.png">
+</p>
+
+<div align="center">
+
+[![Python Versions](https://img.shields.io/pypi/pyversions/perpetual.svg?logo=python&logoColor=white)](https://pypi.org/project/perpetual)
+[![PyPI Version](https://img.shields.io/pypi/v/perpetual.svg?logo=pypi&logoColor=white)](https://pypi.org/project/perpetual)
+[![Crates.io Version](https://img.shields.io/crates/v/perpetual?logo=rust&logoColor=white)](https://crates.io/crates/perpetual)
+[![Static Badge](https://img.shields.io/badge/join-discord-blue?logo=discord)](https://discord.gg/AyUK7rr6wy)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/perpetual)
+
+</div>
+
+# Perpetual
+
+PerpetualBooster is a gradient boosting machine (GBM) algorithm which doesn't need hyperparameter optimization unlike other GBM algorithms. Similar to AutoML libraries, it has a `budget` parameter. Increasing the `budget` parameter increases the predictive power of the algorithm and gives better results on unseen data. Start with a small budget (e.g. 1.0) and increase it (e.g. 2.0) once you are confident with your features. If you don't see any improvement with further increasing the `budget`, it means that you are already extracting the most predictive power out of your data.
+
+## Benchmark
+
+Hyperparameter optimization usually takes 100 iterations with plain GBM algorithms. PerpetualBooster achieves the same accuracy in a single run. Thus, it achieves up to 100x speed-up at the same accuracy with different `budget` levels and with different datasets.
+
+The following table summarizes the results for the [California Housing](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.fetch_california_housing.html) dataset (regression):
+
+| Perpetual budget | LightGBM n_estimators | Perpetual mse | LightGBM mse | Speed-up wall time | Speed-up cpu time |
+| ---------------- | --------------------- | ------------- | ------------ | ------------------ | ----------------- |
+| 1.0              | 100                   | 0.192         | 0.192        | 54x                | 56x               |
+| 1.5              | 300                   | 0.188         | 0.188        | 59x                | 58x               |
+| 2.1              | 1000                  | 0.185         | 0.186        | 42x                | 41x               |
+
+The following table summarizes the results for the [Cover Types](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.fetch_covtype.html) dataset (classification):
+
+| Perpetual budget | LightGBM n_estimators | Perpetual log loss | LightGBM log loss | Speed-up wall time | Speed-up cpu time |
+| ---------------- | --------------------- | ------------------ | ----------------- | ------------------ | ----------------- |
+| 0.9              | 100                   | 0.091              | 0.084             | 72x                | 78x               |
+
+The results can be reproduced using the scripts in the [examples](./python-package/examples) folder.
+
+PerpetualBooster is a GBM but behaves like AutoML so it is benchmarked also against AutoGluon (v1.2, best quality preset), the current leader in [AutoML benchmark](https://automlbenchmark.streamlit.app/cd_diagram). Top 10 datasets with the most number of rows are selected from [OpenML datasets](https://www.openml.org/). The results are summarized in the following table for regression tasks:
+
+| OpenML Task                                  | Perpetual Training Duration | Perpetual Inference Duration                                      | Perpetual RMSE | AutoGluon Training Duration | AutoGluon Inference Duration                                      | AutoGluon RMSE |
+| -------------------------------------------- | --------------------------- | ----------------------------------------------------------------- | -------------- | --------------------------- | ----------------------------------------------------------------- | -------------- |
+| [Airlines_DepDelay_10M](https://www.openml.org/t/359929) | 518                         | 11.3                                                              | 29.0           | 520                         | 30.9 <td style="background-color:green;color:white;"> 28.8 </td>  |
+| [bates_regr_100](https://www.openml.org/t/361940)        | 3421                        | 15.1 <td style="background-color:green;color:white;"> 1.084 </td> | OOM            | OOM                         | OOM                                                               |
+| [BNG(libras_move)](https://www.openml.org/t/7327)        | 1956                        | 4.2 <td style="background-color:green;color:white;"> 2.51 </td>   | 1922           | 97.6                        | 2.53                                                              |
+| [BNG(satellite_image)](https://www.openml.org/t/7326)    | 334                         | 1.6                                                               | 0.731          | 337                         | 10.0 <td style="background-color:green;color:white;"> 0.721 </td> |
+| [COMET_MC](https://www.openml.org/t/14949)               | 44                          | 1.0 <td style="background-color:green;color:white;"> 0.0615 </td> | 47             | 5.0                         | 0.0662                                                            |
+| [friedman1](https://www.openml.org/t/361939)             | 275                         | 4.2 <td style="background-color:green;color:white;"> 1.047 </td>  | 278            | 5.1                         | 1.487                                                             |
+| [poker](https://www.openml.org/t/10102)                  | 38                          | 0.6 <td style="background-color:green;color:white;"> 0.256 </td>  | 41             | 1.2                         | 0.722                                                             |
+| [subset_higgs](https://www.openml.org/t/361955)          | 868                         | 10.6 <td style="background-color:green;color:white;"> 0.420 </td> | 870            | 24.5                        | 0.421                                                             |
+| [BNG(autoHorse)](https://www.openml.org/t/7319)          | 107                         | 1.1 <td style="background-color:green;color:white;"> 19.0 </td>   | 107            | 3.2                         | 20.5                                                              |
+| [BNG(pbc)](https://www.openml.org/t/7318)                | 48                          | 0.6 <td style="background-color:green;color:white;"> 836.5 </td>  | 51             | 0.2                         | 957.1                                                             |
+| average                                      | 465                         | 3.9                                                               | -              | 464                         | 19.7                                                              | -              |
+
+PerpetualBooster outperformed AutoGluon on 8 out of 10 datasets, training equally fast and inferring 5x faster. The results can be reproduced using the automlbenchmark fork [here](https://github.com/deadsoul44/automlbenchmark).
+
+## Usage
+
+You can use the algorithm like in the example below. Check examples folders for both Rust and Python.
+
+```python
+from perpetual import PerpetualBooster
+
+model = PerpetualBooster(objective="SquaredLoss")
+model.fit(X, y, budget=1.0)
+```
+
+## Documentation
+
+Documentation for the Python API can be found [here](https://perpetual-ml.github.io/perpetual) and for the Rust API [here](https://docs.rs/perpetual/latest/perpetual/).
+
+## Installation
+
+The package can be installed directly from [pypi](https://pypi.org/project/perpetual):
+
+```shell
+pip install perpetual
+```
+
+Using [conda-forge](https://anaconda.org/conda-forge/perpetual):
+
+```shell
+conda install conda-forge::perpetual
+```
+
+To use in a Rust project and to get the package from [crates.io](https://crates.io/crates/perpetual):
+
+```shell
+cargo add perpetual
+```
+
+## Contribution
+
+Contributions are welcome. Check CONTRIBUTING.md for the guideline.
+
+## Paper
+
+PerpetualBooster prevents overfitting with a generalization algorithm. The paper is work-in-progress to explain how the algorithm works. Check our [blog post](https://perpetual-ml.com/blog/how-perpetual-works) for a high level introduction to the algorithm.
+

perpetual-0.7.11.dist-info/RECORD

@@ -0,0 +1,12 @@
+perpetual-0.7.11.dist-info/METADATA,sha256=O8rVHCDWs2m0TM1TnOg5Y3CJoG0vmYr7fzbhS1in844,9916
+perpetual-0.7.11.dist-info/WHEEL,sha256=ejgwLTbXJe53teqt8O_fka1tRp0QYpCWayNY4w7JtRY,104
+perpetual-0.7.11.dist-info/license_files/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+perpetual-0.7.11.dist-info/license_files/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+perpetual/serialize.py,sha256=Tg2BbuA1jKQ5-ITuVhwtj6hgBaRAbZ66eHctR7fcVk4,1883
+perpetual/__init__.py,sha256=zzFLkwRr8No7DPUNUQlBXdsdGfT7KEt4orHozdZhS7c,116
+perpetual/types.py,sha256=vBwsX2XnSC8RqdmP2Mr6hDljgWhgGNS6OsuBZM1QdW0,3231
+perpetual/utils.py,sha256=kj6yOF3wjbt40w7twOI7xqWfqu-y7nNJ4SorPT9xBbs,7229
+perpetual/data.py,sha256=718adB9qIc0YvBiTQtMkbT6JPb5liR-4z1UD81IyYhY,590
+perpetual/booster.py,sha256=A5vXeOzzhlHpDB6c2kSIGrmMipG4k8hdcJ0XdSIVGRI,45961
+perpetual/perpetual.cpython-313-darwin.so,sha256=-HTJ3SrTYCMFjqS0XvGEXBz5veAGhcjTXRKI-DJUprI,1406416
+perpetual-0.7.11.dist-info/RECORD,,

perpetual-0.7.11.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.6.0)
+Root-Is-Purelib: false
+Tag: cp313-cp313-macosx_11_0_arm64