obliquetree 1.0.1__cp311-cp311-macosx_11_0_arm64.whl

obliquetree/utils.py

@@ -0,0 +1,526 @@
+from __future__ import annotations
+
+from .src.utils import export_tree as _export_tree
+from ._pywrap import BaseTree, Classifier, Regressor
+import json
+from typing import Optional, Dict, Any, List, Union
+from io import BytesIO
+import os
+
+
+def load_tree(tree_data: Union[str, Dict]) -> Union[Classifier, Regressor]:
+    """
+    Load a decision tree model from a JSON file or dictionary representation.
+
+    This function reconstructs a trained decision tree from its serialized form,
+    either from a JSON file on disk or a dictionary containing the tree structure
+    and parameters.
+
+    Parameters
+    ----------
+    tree_data : Union[str, Dict]
+        Either:
+        - A string containing the file path to a JSON file containing the tree data
+        - A dictionary containing the serialized tree structure and parameters
+
+    Returns
+    -------
+    Union[Classifier, Regressor]
+        A reconstructed decision tree object. The specific type (Classifier or
+        Regressor) is determined by the 'task' parameter in the tree data.
+    """
+    # Handle input types
+    if isinstance(tree_data, str):
+        if not os.path.exists(tree_data):
+            raise FileNotFoundError(f"The file {tree_data} does not exist")
+
+        with open(tree_data, "r") as f:
+            tree = json.load(f)
+    elif isinstance(tree_data, dict):
+        tree = tree_data
+    else:
+        raise ValueError("Input must be a JSON string, file path, or dictionary")
+
+    # Validate tree structure
+    if (
+        not isinstance(tree, dict)
+        or "params" not in tree
+        or "task" not in tree["params"]
+    ):
+        raise ValueError("Invalid tree data structure")
+
+    # Create appropriate object based on task
+    if not tree["params"]["task"]:
+        obj = Classifier.__new__(Classifier)
+    else:
+        obj = Regressor.__new__(Regressor)
+
+    tree["_fit"] = True
+
+    obj.__setstate__(tree)
+    
+    return obj
+
+
+def export_tree(
+    tree: Union[Classifier, Regressor], out_file: str = None
+) -> Union[None, dict]:
+    """
+    Serialize a decision tree model to a dictionary or JSON file.
+
+    This function converts a trained decision tree into a portable format that can
+    be saved to disk or transmitted. The serialized format preserves all necessary
+    information to reconstruct the tree using load_tree().
+
+    Parameters
+    ----------
+    tree : Union[Classifier, Regressor]
+        The trained decision tree model to export. Must be an instance of either
+        Classifier or Regressor and must have been fitted.
+
+    out_file : str, optional
+        If provided, the path where the serialized tree should be saved as a JSON
+        file. If None, the function returns the dictionary representation instead
+        of saving to disk.
+
+    Returns
+    -------
+    Union[None, dict]
+        If out_file is None:
+            Returns a dictionary containing the serialized tree structure and parameters
+        If out_file is provided:
+            Returns None after saving the tree to the specified JSON file
+    """
+    if not isinstance(tree, BaseTree):
+        raise ValueError("`tree` must be an instance of `BaseTree`.")
+
+    if not tree._fit:
+        raise ValueError(
+            "The tree has not been fitted yet. Please call the 'fit' method to train the tree before using this function."
+        )
+
+    tree_dict = _export_tree(tree)  # Assuming this function is implemented elsewhere.
+
+    if out_file is not None:
+        if isinstance(out_file, str):
+            with open(out_file, "w") as f:
+                json.dump(tree_dict, f, indent=4)
+        else:
+            raise ValueError("`out_file` must be a string if provided.")
+
+    else:
+        return tree_dict
+
+
+def visualize_tree(
+    tree: Union[Classifier, Regressor],
+    feature_names: Optional[List[str]] = None,
+    max_cat: Optional[int] = None,
+    max_oblique: Optional[int] = None,
+    save_path: Optional[str] = None,
+    dpi: int = 600,
+    figsize: tuple = (20, 10),
+    show_gini: bool = True,
+    show_n_samples: bool = True,
+    show_node_value: bool = True,
+) -> None:
+    """
+    Generate a visual representation of a decision tree model.
+
+    Creates a graphical visualization of the tree structure showing decision nodes,
+    leaf nodes, and split criteria. The visualization can be customized to show
+    various node statistics and can be displayed or saved to a file.
+
+    Parameters
+    ----------
+    tree : Union[Classifier, Regressor]
+        The trained decision tree model to visualize. Must be fitted before
+        visualization.
+
+    feature_names : List[str], optional
+        Human-readable names for the features used in the tree. If provided,
+        these names will be used in split conditions instead of generic feature
+        indices (e.g., "age <= 30" instead of "f0 <= 30").
+
+    max_cat : int, optional
+        For categorical splits, limits the number of categories shown in the
+        visualization. If there are more categories than this limit, they will
+        be truncated with an ellipsis. Useful for splits with many categories.
+
+    max_oblique : int, optional
+        For oblique splits (those involving multiple features), limits the number
+        of features shown in the split condition. Helps manage complex oblique
+        splits in the visualization.
+
+    save_path : str, optional
+        If provided, saves the visualization to this file path. The file format
+        is determined by the file extension (e.g., '.png', '.pdf').
+
+    dpi : int, default=600
+        The resolution (dots per inch) of the saved image. Only relevant if
+        save_path is provided.
+
+    figsize : tuple, default=(20, 10)
+        The width and height of the figure in inches.
+
+    show_gini : bool, default=True
+        Whether to display Gini impurity values in the nodes.
+
+    show_n_samples : bool, default=True
+        Whether to display the number of samples that reach each node.
+
+    show_node_value : bool, default=True
+        Whether to display the predicted value/class distributions in each node.
+
+    Returns
+    -------
+    None
+        The function displays the visualization and optionally saves it to disk.
+    """
+    _check_visualize_tree_inputs(
+        tree, feature_names, max_cat, max_oblique, save_path, dpi, figsize
+    )
+
+    try:
+        from graphviz import Digraph
+    except ImportError:
+        raise ImportError(
+            "graphviz is not installed. Please install it to use this function."
+        )
+
+    try:
+        from matplotlib.pyplot import figure, imshow, imread, axis, savefig, show
+    except:
+        raise ImportError(
+            "matplotlib is not installed. Please install it to use this function."
+        )
+
+    tree_dict = _export_tree(tree)  # Assuming this function is implemented elsewhere.
+
+    node, params = tree_dict["tree"], tree_dict["params"]
+
+    def _visualize_recursive(node, graph=None, parent=None, edge_label=""):
+        if graph is None:
+            graph = Digraph(format="png")
+            graph.graph_attr.update(
+                {
+                    "rankdir": "TB",
+                    "ranksep": "0.3",
+                    "nodesep": "0.2",
+                    "splines": "polyline",
+                    "ordering": "out",
+                }
+            )
+            graph.attr(
+                "node",
+                shape="box",
+                style="filled",
+                color="lightgrey",
+                fontname="Helvetica",
+                margin="0.2",
+            )
+
+        node_id = str(id(node))
+        label_parts = []
+
+        is_leaf = "left" not in node and "right" not in node
+
+        if is_leaf:
+            # For leaf nodes
+            label_parts.append("leaf")
+            label_parts.append(_format_value_str(node, params))
+
+            # Add impurity for leaf nodes if requested and available
+            if show_gini and "impurity" in node:
+                label_parts.append(f"impurity: {_format_float(node['impurity'])}")
+
+            # Add n_samples for leaf nodes if requested and available
+            if show_n_samples and "n_samples" in node:
+                label_parts.append(f"n_samples: {node['n_samples']}")
+
+            graph.node(
+                node_id,
+                label="\n".join(label_parts),
+                shape="box",
+                style="filled",
+                color="lightblue",
+                fontname="Helvetica",
+            )
+        else:
+            # For internal nodes
+            # First add the split information
+            if node.get("is_oblique", False):
+                split_info = _create_oblique_expression(
+                    node["features"],
+                    node["weights"],
+                    node["threshold"],
+                    feature_names,
+                    max_oblique,
+                )
+            elif "category_left" in node:
+                categories = node["category_left"]
+                cat_str = _format_categories(categories, max_cat)
+                feature_label = (
+                    feature_names[node["feature_idx"]]
+                    if feature_names and node["feature_idx"] < len(feature_names)
+                    else f"f{node['feature_idx']}"
+                )
+                split_info = f"{feature_label} in {cat_str}"
+            else:
+                threshold = (
+                    _format_float(node["threshold"])
+                    if isinstance(node["threshold"], float)
+                    else node["threshold"]
+                )
+                feature_label = (
+                    feature_names[node["feature_idx"]]
+                    if feature_names and node["feature_idx"] < len(feature_names)
+                    else f"f{node['feature_idx']}"
+                )
+                split_info = f"{feature_label} ≤ {threshold}"
+
+            label_parts.append(split_info)
+
+            if show_node_value:
+                label_parts.append(_format_value_str(node, params))
+
+            # Add Gini impurity if requested
+            if show_gini and "impurity" in node:
+                label_parts.append(f"impurity: {_format_float(node['impurity'])}")
+
+            # Add n_samples if requested
+            if show_n_samples and "n_samples" in node:
+                label_parts.append(f"n_samples: {node['n_samples']}")
+
+            graph.node(
+                node_id,
+                label="\n".join(label_parts),
+                shape="box",
+                style="filled",
+                color="lightgrey",
+                fontname="Helvetica",
+            )
+
+        if parent is not None:
+            graph.edge(
+                parent,
+                node_id,
+                label=edge_label,
+                fontname="Helvetica",
+                penwidth="1.0",
+                minlen="1",
+            )
+
+        if "left" in node:
+            _visualize_recursive(node["left"], graph, node_id, "Left")
+        if "right" in node:
+            _visualize_recursive(node["right"], graph, node_id, "Right")
+
+        return graph
+
+    graph = _visualize_recursive(node)
+    png_data = graph.pipe(format="png")
+
+    figure(figsize=figsize)
+    imshow(imread(BytesIO(png_data)))
+    axis("off")
+
+    if save_path:
+        savefig(save_path, dpi=dpi, bbox_inches="tight", pad_inches=0)
+
+    show()
+
+
+def _format_float(value: float) -> str:
+    """Format float value with 3 decimal places, return '0' for 0.0"""
+    if value == 0.0:
+        return "0"
+    return f"{value:.2f}"
+
+
+def _format_value_str(node: Dict[str, Any], params: Dict[str, Any]) -> str:
+    """
+    Format value string based on task type (regression vs classification) and number of classes
+
+    Parameters:
+    -----------
+    node : Dict[str, Any]
+        The tree node dictionary containing values or value
+    params : Dict[str, Any]
+        Tree parameters containing task and n_classes information
+    """
+    # Check if it's a regression task
+    if params["task"]:
+        value = (
+            _format_float(node["value"])
+            if isinstance(node["value"], float)
+            else node["value"]
+        )
+        return f"Value: {value}"
+
+    # Classification task
+    else:
+        if params["n_classes"] == 2:  # Binary classification
+            # For binary case, node["values"] contains probability for positive class
+            p = node["value"]
+            return f"values: [{_format_float(1-p)}, {_format_float(p)}]"
+        else:  # Multiclass (3 or more classes)
+            values_str = ", ".join(
+                _format_float(v) if isinstance(v, float) else str(v)
+                for v in node.get("values", [0.0] * params["n_classes"])
+            )
+            return f"values: [{values_str}]"
+
+
+def _create_oblique_expression(
+    features: list,
+    weights: list,
+    threshold: float,
+    feature_names: Optional[List[str]],
+    max_oblique: Optional[int] = None,
+) -> str:
+    """Create mathematical expression for oblique split with line breaks after 5 terms"""
+    terms = []
+
+    # Sort features and weights by absolute weight value
+    feature_weight_pairs = sorted(
+        zip(features, weights), key=lambda x: abs(x[1]), reverse=True
+    )
+
+    # Apply max_oblique limit if specified
+    if max_oblique is not None:
+        feature_weight_pairs = feature_weight_pairs[:max_oblique]
+        if len(features) > max_oblique:
+            feature_weight_pairs.append(("...", 0))
+
+    # Create terms with proper formatting
+    lines = []
+    current_line = []
+
+    for i, (f, w) in enumerate(feature_weight_pairs):
+        if f == "...":
+            current_line.append("...")
+            continue
+
+        feature_label = (
+            feature_names[f] if feature_names and f < len(feature_names) else f"f{f}"
+        )
+
+        if w == 1.0:
+            term = feature_label  # Removed parentheses for coefficient 1
+        elif w == -1.0:
+            term = f"–{feature_label}"  # Removed parentheses for coefficient -1
+        else:
+            formatted_weight = _format_float(abs(w))
+            term = f"{'– ' if w < 0 else ''}({formatted_weight} * {feature_label})"
+
+        if i > 0:
+            term = f"+ {term}" if w > 0 else f" {term}"
+
+        current_line.append(term)
+
+        # Start new line after every 5 terms
+        if len(current_line) == 5 and i < len(feature_weight_pairs) - 1:
+            lines.append(" ".join(current_line) + " +")
+            current_line = []
+
+    if current_line:
+        lines.append(" ".join(current_line))
+
+    formatted_threshold = _format_float(threshold)
+    expression = "\n".join(lines)
+    return f"{expression} ≤ {formatted_threshold}"
+
+
+def _format_categories(categories: list, max_cat: Optional[int] = None) -> str:
+    """Format category list with line breaks after every 5 items"""
+    if max_cat is not None and len(categories) > max_cat:
+        shown_cats = categories[:max_cat]
+        return f"[{', '.join(map(str, shown_cats))}, ...]"
+
+    formatted_cats = []
+    current_line = []
+
+    for i, cat in enumerate(categories):
+        current_line.append(str(cat))
+
+        # Add line break after every 5 items or at the end
+        if len(current_line) == 9 and i < len(categories) - 1:
+            formatted_cats.append(", ".join(current_line) + ",")
+            current_line = []
+
+    if current_line:
+        formatted_cats.append(", ".join(current_line))
+
+    if len(formatted_cats) > 1:
+        return "[" + "\n".join(formatted_cats) + "]"
+    return f"[{formatted_cats[0]}]"
+
+
+def _check_visualize_tree_inputs(
+    tree: BaseTree,
+    feature_names: Optional[List[str]] = None,
+    max_cat: Optional[int] = None,
+    max_oblique: Optional[int] = None,
+    save_path: Optional[str] = None,
+    dpi: int = 600,
+    figsize: tuple = (20, 10),
+) -> None:
+    """
+    Validate the inputs for the visualize_tree function.
+
+    Parameters:
+    -----------
+    tree : object
+        The tree object to be visualized, must have a certain expected structure.
+    feature_names : Optional[List[str]]
+        If provided, must be a list of strings matching the number of features in the tree.
+    max_cat : Optional[int]
+        If provided, must be a positive integer.
+    max_oblique : Optional[int]
+        If provided, must be a positive integer.
+    save_path : Optional[str]
+        If provided, must be a valid file path ending in a supported image format (e.g., '.png').
+    dpi : int
+        Must be a positive integer.
+    figsize : tuple
+        Must be a tuple of two positive numbers.
+    """
+    if not isinstance(tree, BaseTree):
+        raise ValueError("`tree` must be an instance of `BaseTree`.")
+
+    if not tree._fit:
+        raise ValueError(
+            "The tree has not been fitted yet. Please call the 'fit' method to train the tree before using this function."
+        )
+
+    if feature_names is not None:
+        if not isinstance(feature_names, list) or not all(
+            isinstance(f, str) for f in feature_names
+        ):
+            raise ValueError("feature_names must be a list of strings.")
+        if len(feature_names) != tree.n_features:
+            raise ValueError(
+                f"feature_names must match the number of features in the tree ({tree.n_features})."
+            )
+
+    if max_cat is not None and (not isinstance(max_cat, int) or max_cat <= 0):
+        raise ValueError("max_cat must be a positive integer.")
+
+    if max_oblique is not None and (
+        not isinstance(max_oblique, int) or max_oblique <= 0
+    ):
+        raise ValueError("max_oblique must be a positive integer.")
+
+    if save_path is not None and not isinstance(save_path, str):
+        raise ValueError("save_path must be a string representing a valid file path.")
+
+    if not isinstance(dpi, int) or dpi <= 0:
+        raise ValueError("dpi must be a positive integer.")
+
+    if (
+        not isinstance(figsize, tuple)
+        or len(figsize) != 2
+        or not all(isinstance(dim, (int, float)) and dim > 0 for dim in figsize)
+    ):
+        raise ValueError("figsize must be a tuple of two positive numbers.")

obliquetree-1.0.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Samet Çopur
+
+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.

obliquetree-1.0.1.dist-info/METADATA

@@ -0,0 +1,113 @@
+Metadata-Version: 2.2
+Name: obliquetree
+Version: 1.0.1
+Summary: Traditional and Oblique Decision Tree
+Author-email: Samet Copur <sametcopur@yahoo.com>
+License: MIT License
+Project-URL: Documentation, https://obliquetree.readthedocs.io/en/latest/
+Project-URL: Repository, https://github.com/sametcopur/obliquetree
+Project-URL: Tracker, https://github.com/sametcopur/obliquetree/issues
+Keywords: python,data-science,machine-learning,machine-learning-library,explainable-ai,decision-tree,oblique-tree
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.2.1
+Requires-Dist: scipy>=1.15.0
+
+# obliquetree
+
+`obliquetree` is an advanced decision tree implementation designed to provide high-performance and interpretable models. It supports both classification and regression tasks, enabling a wide range of applications. By offering traditional and oblique splits, it ensures flexibility and improved generalization with shallow trees. This makes it a powerful alternative to regular decision trees.
+
+
+![Tree Visualization](docs/source/_static/tree_visual.png)
+
+
+----
+
+## Getting Started
+
+`obliquetree` combines advanced capabilities with efficient performance. It supports **oblique splits**, leveraging **L-BFGS optimization** to determine the best linear weights for splits, ensuring both speed and accuracy.
+
+In **traditional mode**, without oblique splits, `obliquetree` outperforms `scikit-learn` in terms of speed and adds support for **categorical variables**, providing a significant advantage over many traditional decision tree implementations.
+
+When the **oblique feature** is enabled, `obliquetree` dynamically selects the optimal split type between oblique and traditional splits. If no weights can be found to reduce impurity, it defaults to an **axis-aligned split**, ensuring robustness and adaptability in various scenarios.
+
+In very large trees (e.g., depth 10 or more), the performance of `obliquetree` may converge closely with **traditional trees**. The true strength of `obliquetree` lies in their ability to perform exceptionally well at **shallower depths**, offering improved generalization with fewer splits. Moreover, thanks to linear projections, `obliquetree` significantly outperform traditional trees when working with datasets that exhibit **linear relationships**.
+
+-----
+## Installation
+To install `obliquetree`, use the following pip command:
+```bash
+pip install obliquetree
+```
+
+Using the `obliquetree` library is simple and intuitive. Here's a more generic example that works for both classification and regression:
+
+
+```python
+from obliquetree import Classifier, Regressor
+
+# Initialize the model (Classifier or Regressor)
+model = Classifier(  # Replace "Classifier" with "Regressor" if performing regression
+    use_oblique=True,       # Enable oblique splits
+    max_depth=2,            # Set the maximum depth of the tree
+    n_pair=2,               # Number of feature pairs for optimization
+    random_state=42,        # Set a random state for reproducibility
+    categories=[0, 10, 32], # Specify which features are categorical
+)
+
+# Train the model on the training dataset
+model.fit(X_train, y_train)
+
+# Predict on the test dataset
+y_pred = model.predict(X_test)
+```
+-----
+
+## Documentation
+For example usage, API details, comparisons with axis-aligned trees, and in-depth insights into the algorithmic foundation, we **strongly recommend** referring to the full [documentation](https://obliquetree.readthedocs.io/en/latest/).
+
+---
+## Key Features
+
+- **Oblique Splits**  
+  Perform oblique splits using linear combinations of features to capture complex patterns in data. Supports both linear and soft decision tree objectives for flexible and accurate modeling.
+
+- **Axis-Aligned Splits**  
+  Offers conventional (axis-aligned) splits, enabling users to leverage standard decision tree behavior for simplicity and interpretability.
+
+- **Feature Constraints**  
+  Limit the number of features used in oblique splits with the `n_pair` parameter, promoting simpler, more interpretable tree structures while retaining predictive power.
+
+- **Seamless Categorical Feature Handling**  
+  Natively supports categorical columns with minimal preprocessing. Only label encoding is required, removing the need for extensive data transformation.
+
+- **Robust Handling of Missing Values**  
+  Automatically assigns `NaN` values to the optimal leaf for axis-aligned splits.
+
+- **Customizable Tree Structures**  
+  The flexible API empowers users to design their own tree architectures easily.
+
+- **Exact Equivalence with `scikit-learn`**  
+  Guarantees results identical to `scikit-learn`'s decision trees when oblique and categorical splitting are disabled.
+
+- **Optimized Performance**  
+  Outperforms `scikit-learn` in terms of speed and efficiency when oblique and categorical splitting are disabled:
+  - Up to **50% faster** for datasets with float columns.
+  - Up to **200% faster** for datasets with integer columns.
+
+  ![Performance Comparison (Float)](docs/source/_static/sklearn_perf/performance_comparison_float.png)
+
+  ![Performance Comparison (Integer)](docs/source/_static/sklearn_perf/performance_comparison_int.png)
+
+
+----
+### Contributing
+Contributions are welcome! If you'd like to improve `obliquetree` or suggest new features, feel free to fork the repository and submit a pull request.
+
+-----
+### License
+`obliquetree` is released under the MIT License. See the LICENSE file for more details.

obliquetree-1.0.1.dist-info/RECORD

@@ -0,0 +1,21 @@
+obliquetree-1.0.1.dist-info/RECORD,,
+obliquetree-1.0.1.dist-info/LICENSE,sha256=lLpW3hLh8QbaRAWXRaZ76c80HoVfUr6739D0S7ecslU,1069
+obliquetree-1.0.1.dist-info/WHEEL,sha256=NW1RskY9zow1Y68W-gXg0oZyBRAugI1JHywIzAIai5o,109
+obliquetree-1.0.1.dist-info/top_level.txt,sha256=m-5N4-iAS5MsFOdk8y1r2ya_i5rVQBgPayHBA-K26qg,12
+obliquetree-1.0.1.dist-info/METADATA,sha256=_6KQMjXzPh7zw-b0KVnGB9hWUziugEiy_ZUUgaZIfrU,5640
+obliquetree/__init__.py,sha256=hER789IcI7j2GnsVNvUhdVUjPJemBfHd2ztSOZgRwW8,81
+obliquetree/utils.py,sha256=coNk6PATedhTTBoapJ6rb0SI4TSfRYxI6bBnGAwAO_Y,17976
+obliquetree/_pywrap.py,sha256=pzx9tUbzb_4Brw6UOgYFVMv9VIfupDkJBLh5m1tUTEo,25754
+obliquetree/src/base.cpython-311-darwin.so,sha256=ktGj5MbnjyrABkNEwaZgO2-O9eKHG2gQanprBpuaW5k,252696
+obliquetree/src/utils.cpp,sha256=7Q5r4Ko31co4Rf90RTnLzKUmw9fDmrkfjyXr0gGXNJ8,1227838
+obliquetree/src/ccp.cpython-311-darwin.so,sha256=M7smNrFzBuXadpV7oZgkkeLM8G65f-05rwHKLIWsvOg,168776
+obliquetree/src/oblique.cpp,sha256=rqdaDM2dqID-7X8MXdRMz3PMSP6QWddZteiFf1yqskQ,1360036
+obliquetree/src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+obliquetree/src/base.cpp,sha256=dXMTiOZ4TLupIdvV3-dXmqnpQ04JFTf5J4AIzmg_dKc,1427982
+obliquetree/src/tree.cpp,sha256=u7Bni3IDrVuKOwAnrL1RJ2ZO5GBlCOKNV0VSZtBWNoc,1137319
+obliquetree/src/oblique.cpython-311-darwin.so,sha256=L9cPcpxuUmK-jPJdPNJB-uNOxHpz-clj96h_Ept3jx4,274464
+obliquetree/src/metric.cpp,sha256=a8EQXx-oG4zUaAGizOiETEbOiqmwMkdkfZsLu_Lq_Wo,1174065
+obliquetree/src/utils.cpython-311-darwin.so,sha256=fR27zP7WI7M0w_8Liajyn185E5N-xZmlSU_Svwc4NsU,255832
+obliquetree/src/ccp.cpp,sha256=EE1KaqH9Nt3jDojBcr6TRd4KjKv3LMQAAfkDkNGaYP4,944586
+obliquetree/src/tree.cpython-311-darwin.so,sha256=YfiWiXDAiy8dw8A3ZCQqFlbHcc7RhiaW_0-ea7FYhL4,186344
+obliquetree/src/metric.cpython-311-darwin.so,sha256=cylxsZDHXhDJ-tdXO2a_SLVcV2Pv1I-FMLgHSnzWSis,186528

obliquetree-1.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.0)
+Root-Is-Purelib: false
+Tag: cp311-cp311-macosx_11_0_arm64
+

obliquetree-1.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+obliquetree