path-boost 2.1.0__py3-none-any.whl

path_boost/utils/variable_importance_according_to_path_boost.py

@@ -0,0 +1,341 @@
+import logging
+import warnings
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .classes.sequential_path_boost import SequentialPathBoost
+
+import numpy as np
+import pandas as pd
+
+logger = logging.getLogger("path_boost")
+from collections import defaultdict
+from .classes.extended_boosting_matrix import ExtendedBoostingMatrix
+from sklearn.metrics import mean_squared_error, mean_absolute_error
+
+
+class VariableImportance_ForSequentialPathBoost:
+    # this class is used to compute the variable importance according to the path boost algorithm
+    # note, that for the relative variable importance, we need hevvy rely on the fact that the loss function passed
+    # to the base learner is mse, if changed we can not guarantee the correct behaviour of the algorithm
+
+    def __init__(
+        self,
+        criterion: str,
+        use_correlation: bool = False,
+        normalize: bool = True,
+        error_used: str = "mse",
+        normalization_value: float = 100,
+    ):
+        assert (
+            error_used == "mse" or error_used == "mae"
+        ), f"error must be either mse or mae, but got {error_used}"
+        assert (
+            criterion == "absolute" or criterion == "relative"
+        ), f"criterion must be either absolute or relative, but got {criterion}"
+
+        self.error_used = error_used
+        self.criterion = criterion
+        self.use_correlation = use_correlation
+        self.normalize = normalize
+
+        self.normalization_value = normalization_value
+
+        criterion_choices = {
+            "absolute": self.compute_absolute_variable_importance,
+            "relative": self.compute_relative_variable_importance,
+        }
+        self.compute_variable_importance = criterion_choices[criterion]
+
+        # all the selected paths in order of selection
+        self.selected_path_at_iteration = []
+        self.columns_at_iteration = []
+        self.gradient_at_iteration = []
+
+    def _update(
+        self,
+        path_boost: "SequentialPathBoost",
+        selected_path: tuple,
+        iteration_number: int,
+        gradient: np.ndarray | None = None,
+    ):
+        # update is used during training in sequential path boost to save, at each iteration the parameters needed later for the computation of the path importance
+        # NB we expect that gradient is just y if we are in the first (0-th) iteration
+        # NB we expect that absolute_error is None if we are in the first (0-th) iteration
+
+        # check that the base learner has been already trained in this iteration
+        assert iteration_number == len(path_boost.base_learner_.train_mse), (
+            f"iteration number {iteration_number} does not match the number of base"
+            f" learners {len(path_boost.base_learner_.train_mse)}"
+        )
+
+        # check that the ebm has not been expanded yet
+        assert path_boost._ebm_has_been_expanded_in_this_iteration is False
+
+        columns_names = path_boost.train_ebm_dataframe_.columns
+
+        self.selected_path_at_iteration.append(selected_path)
+        self.columns_at_iteration.append(columns_names)
+
+        self.gradient_at_iteration.append(gradient)
+
+    def compute_absolute_variable_importance(
+        self, path_boost: "SequentialPathBoost"
+    ) -> dict:
+        # compute importance by error improvement
+        # if we are in the first iteration there is no previous error to compare with, then we set it equal to the second eror improvement
+        # note: one can think to compare the first iteration with the error that we would have if we would have used
+        # the mean of the labels (that is the variance of the labels in the case of MSE) however this does not work since
+        # the bae learner is limited by the learining rate, sometimes making it first training even worse than the mean
+
+        # check that the iteration number is correct
+        # if the iteration number does not coincide with the number of base learners (same as the number of errors)
+        # it means we are in a new iteration, but we still have to train the base_learner
+
+        error_improvement = defaultdict(float)
+        previous_improvement = 0
+        for iteration in range(path_boost.n_iter):
+            if iteration == 0:
+                # in the first iteration we do not have a previous error to compare with so we skip
+                pass
+            else:
+                path = self.selected_path_at_iteration[iteration]
+                if self.error_used == "mse":
+                    improvement = (
+                        path_boost.train_mse_[iteration - 1]
+                        - path_boost.train_mse_[iteration]
+                    )
+                    if improvement < 0 and previous_improvement > 0:
+                        logger.debug(
+                            f"error improvement between iteration {iteration} and"
+                            f" {iteration - 1} is negative ({improvement}). This is"
+                            " expected by the algorithm, but it might be a sign of"
+                            " overfitting even if we are comparing the improvement on"
+                            " the train error"
+                        )
+                    error_improvement[path] += improvement
+
+                elif self.error_used == "mae":
+                    improvement = (
+                        path_boost.train_mae_[iteration - 1]
+                        - path_boost.train_mae_[iteration]
+                    )
+                    if improvement < 0 and previous_improvement > 0:
+                        logger.debug(
+                            f"error improvement between iteration {iteration} and"
+                            f" {iteration - 1} is negative. This is expected by the"
+                            " algorithm, but it might be a sign of overfitting even if"
+                            " we are comparing the improvement on the train error"
+                        )
+                    error_improvement[path] += improvement
+                previous_improvement = improvement
+
+                if iteration == 1:
+                    # since we did not set any importance for the path selected in the zeroth iteration,
+                    # we now set it equal to the importance assignet to the second-selected path
+                    first_selected_path = self.selected_path_at_iteration[0]
+                    if self.error_used == "mse":
+                        error_improvement[first_selected_path] = (
+                            path_boost.train_mse_[0] - path_boost.train_mse_[1]
+                        )
+                    elif self.error_used == "mae":
+                        error_improvement[first_selected_path] = (
+                            path_boost.train_mae_[0] - path_boost.train_mae_[1]
+                        )
+
+        dict_error_improvement = self._get_correlation_and_normalize_if_needed(
+            path_boost=path_boost, error_improvement=error_improvement
+        )
+
+        return dict_error_improvement
+
+    def compute_relative_variable_importance(
+        self, path_boost: "SequentialPathBoost"
+    ) -> dict:
+        # this is a relative measure of importance
+        # it is computed as the ratio between the error improvement of a the second best path and the error improvement of the best path
+
+        error_improvement = defaultdict(float)
+        for iteration in range(path_boost.n_iter):
+            selected_path_at_iteration = self.selected_path_at_iteration[iteration]
+
+            train_ebm_dataframe_at_iteration = path_boost.train_ebm_dataframe_[
+                self.columns_at_iteration[iteration]
+            ]
+
+            frequency_matrix_at_iteration = (
+                ExtendedBoostingMatrix.get_frequency_boosting_matrix(
+                    train_ebm_dataframe_at_iteration
+                )
+            )
+
+            frequency_path_name = (
+                ExtendedBoostingMatrix.generate_frequency_column_name_for_path(
+                    path_label=selected_path_at_iteration
+                )
+            )
+            frequency_matrix_without_best_path = frequency_matrix_at_iteration.drop(
+                frequency_path_name, axis=1, inplace=False
+            )
+
+            gradient = self.gradient_at_iteration[iteration]
+
+            # get the second-best path
+            if iteration == 0:
+                # in the first iteration we do not have a previous error to compare with so we skip
+                continue
+
+            second_best_path = path_boost._find_best_path(
+                train_ebm_dataframe=frequency_matrix_without_best_path,
+                y=gradient,
+                SelectorClass=path_boost.SelectorClass,
+                kwargs_for_selector=path_boost.kwargs_for_selector,
+            )
+
+            # fit a new base learner on the second-best path
+            columns_to_keep = ExtendedBoostingMatrix.get_columns_related_to_path(
+                second_best_path, train_ebm_dataframe_at_iteration.columns
+            )
+            restricted_df = train_ebm_dataframe_at_iteration[columns_to_keep]
+
+            new_base_learner = path_boost.BaseLearnerClass(
+                **path_boost.kwargs_for_base_learner
+            )
+
+            new_base_learner.fit(restricted_df, gradient)
+            if self.error_used == "mse":
+                new_base_learner_prediction = path_boost.learning_rate * pd.Series(
+                    new_base_learner.predict(restricted_df)
+                )
+                new_base_learner_error = mean_squared_error(
+                    y_true=gradient, y_pred=new_base_learner_prediction
+                )
+
+                error_difference = (
+                    new_base_learner_error - path_boost.train_mse_[iteration]
+                )
+
+            elif self.error_used == "mae":
+                new_base_learner_prediction = path_boost.learning_rate * pd.Series(
+                    new_base_learner.predict(restricted_df)
+                )
+                new_base_learner_error = mean_absolute_error(
+                    y_true=gradient, y_pred=new_base_learner_prediction
+                )
+
+                error_difference = (
+                    new_base_learner_error - path_boost.train_mae_[iteration]
+                )
+
+            # update the error improvement
+            error_improvement[selected_path_at_iteration] += error_difference
+
+        dict_error_improvement = self._get_correlation_and_normalize_if_needed(
+            path_boost=path_boost, error_improvement=error_improvement
+        )
+
+        return dict_error_improvement
+
+    def _get_correlation_and_normalize_if_needed(
+        self, path_boost: "SequentialPathBoost", error_improvement: dict
+    ) -> dict:
+        dict_error_improvement = dict(error_improvement)
+
+        if self.use_correlation:
+            # we need to compute the correlation between the paths
+            dict_error_improvement = self.correlation_importance(
+                path_boost, dict_error_improvement
+            )
+
+        if self.normalize:
+            total_error_improvement = sum(dict_error_improvement.values())
+            for path in dict_error_improvement.keys():
+                dict_error_improvement[path] = (
+                    dict_error_improvement[path] / total_error_improvement
+                ) * self.normalization_value
+        return dict_error_improvement
+
+    def correlation_importance(
+        self, path_boost: "SequentialPathBoost", variable_importance: dict
+    ) -> dict:
+        # we want the ebm dataframe only for the paths tha have some importance
+        frequency_name_of_the_paths = [
+            ExtendedBoostingMatrix.generate_frequency_column_name_for_path(
+                path_label=path
+            )
+            for path in variable_importance.keys()
+        ]
+        train_ebm_dataframe = path_boost.train_ebm_dataframe_[
+            frequency_name_of_the_paths
+        ]
+
+        frequency_matrix = ExtendedBoostingMatrix.get_frequency_boosting_matrix(
+            train_ebm_dataframe
+        )
+
+        # get the correlation matrix
+        correlation_matrix = frequency_matrix.corr()
+
+        # The keys in variable_importance and the correlation matrix must match.
+        # variable_importance is a dict with tuple keys; correlation_matrix is a pd.DataFrame.
+
+        correlation_variable_importance = dict()
+        for path in variable_importance.keys():
+            frequency_name_of_path = (
+                ExtendedBoostingMatrix.generate_frequency_column_name_for_path(
+                    path_label=path
+                )
+            )
+            correlation_variable_importance[path] = variable_importance[path]
+            for second_path in variable_importance.keys():
+                frequency_name_of_second_path = (
+                    ExtendedBoostingMatrix.generate_frequency_column_name_for_path(
+                        path_label=second_path
+                    )
+                )
+                if (
+                    len(path) > len(second_path)
+                    and path[: len(second_path)] == second_path
+                ):
+                    corr = correlation_matrix.loc[
+                        frequency_name_of_path, frequency_name_of_second_path
+                    ]
+                    if not pd.isna(corr):
+                        # we want to add the correlation only if it is not nan, it is nan
+                        correlation_variable_importance[path] += (
+                            corr * variable_importance[second_path]
+                        )
+
+        return correlation_variable_importance
+
+    def combine_variable_importance_from_list_of_sequential_models(
+        self,
+        sequential_models: list,
+    ) -> dict:
+        variable_importance_dictionary = defaultdict(list)
+        total_obs = 0
+        for sequential_model in sequential_models:
+            if sequential_model is not None:
+                # we want to get the variable importance of each model and sum all them up
+                n_obs = sequential_model.train_ebm_dataframe_.shape[0]
+                total_obs += n_obs
+                for key, value in sequential_model.variable_importance_.items():
+                    variable_importance_dictionary[key].append(value * n_obs)
+
+        averaged_variable_importance = {}
+        for key, value_list in variable_importance_dictionary.items():
+            if value_list:  # Check if the list is not empty to avoid division by zero
+                averaged_variable_importance[key] = sum(value_list) / (
+                    len(value_list) * total_obs
+                )
+            else:
+                averaged_variable_importance[key] = 0
+
+        if self.normalize:
+            total_error_improvement = sum(averaged_variable_importance.values())
+            for path in averaged_variable_importance.keys():
+                averaged_variable_importance[path] = (
+                    averaged_variable_importance[path] / total_error_improvement
+                ) * self.normalization_value
+
+        return averaged_variable_importance

path_boost-2.1.0.dist-info/METADATA

@@ -0,0 +1,174 @@
+Metadata-Version: 2.4
+Name: path_boost
+Version: 2.1.0
+Summary: Interpretable machine learning on graph-structured data using path-based boosting.
+Author-email: Vighnesh Birodkar <vighneshbirodkar@nyu.edu>, Guillaume Lemaitre <g.lemaitre58@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Claudio-Me/extended_path_boost
+Project-URL: Issues, https://github.com/Claudio-Me/extended_path_boost/issues
+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: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: scikit-learn>=1.4.2
+Requires-Dist: networkx>=3.0
+Requires-Dist: pandas>=2.0
+Requires-Dist: numpy>=1.24
+Requires-Dist: matplotlib>=3.5
+Requires-Dist: joblib>=1.2
+Requires-Dist: scipy>=1.10
+Provides-Extra: progress
+Requires-Dist: tqdm>=4.64; extra == "progress"
+Provides-Extra: all
+Requires-Dist: tqdm>=4.64; extra == "all"
+Dynamic: license-file
+
+# Path Boost
+
+Path Boost is a Python library for interpretable machine learning on graph-structured data. It implements the PathBoost and SequentialPathBoost algorithms, which iteratively construct features based on paths in graphs and use boosting to build predictive models. The library is designed for tasks where input data consists of collections of graphs (e.g., molecules, social networks) and supports variable importance analysis for interpretability.
+
+## Features
+
+- **PathBoost**: Ensemble learning over graph paths, partitioned by anchor nodes.
+- **SequentialPathBoost**: Boosting with path-based features, iteratively expanding the feature space.
+- **Variable Importance**: Quantifies the importance of paths/features in prediction.
+- **Parallel Training**: Supports multi-core training for large datasets.
+- **Evaluation and Visualization**: Built-in tools for error tracking and variable importance plotting.
+
+## Installation
+
+Install from PyPI:
+
+```bash
+pip install path_boost
+```
+
+## Usage Example
+
+Below is a minimal example using the `PathBoost` model:
+
+```python
+import numpy as np
+import networkx as nx
+from sklearn.model_selection import train_test_split
+from path_boost import PathBoost
+from path_boost.utils.datasets_for_examples.generate_example_dataset import generate_synthetic_graph_dataset
+
+
+
+
+if __name__ == "__main__":
+
+    # Generate synthetic dataset
+    nx_graphs, y, true_paths, true_weights = generate_synthetic_graph_dataset()
+
+
+    list_anchor_nodes_labels = [0, 1, 2]
+
+    parameters_variable_importance: dict = {
+        'criterion': 'absolute',
+        'error_used': 'mse',
+        'use_correlation': False,
+        'normalize': True,
+    }
+
+    X_train, X_test, y_train, y_test = train_test_split(nx_graphs, y, test_size=0.25, random_state=42)
+
+    eval_set = [(X_test, y_test)]
+
+    path_boost = PathBoost(
+        n_iter=50, # Reduced for quicker example run
+        max_path_length=5,
+        learning_rate=0.1,
+        n_of_cores=1, # Set to >1 for parallel processing if desired
+        verbose=True,
+        parameters_variable_importance=parameters_variable_importance
+    )
+
+    # Fit the model
+    # anchor_nodes_label_name must correspond to the feature storing node types ('feature_0')
+    path_boost.fit(
+        X=X_train,
+        y=y_train,
+        eval_set=eval_set,
+        list_anchor_nodes_labels=list_anchor_nodes_labels,
+        anchor_nodes_label_name="feature_0" # Node types are in 'feature_0'
+    )
+    
+    print(f"Generated {len(nx_graphs)} graphs.")
+    print(f"Example y values: {y[:5]}")
+    print(f"True paths definitions: {true_paths}")
+    print(f"True path weights: {true_weights}")
+
+    path_boost.plot_training_and_eval_errors(skip_first_n_iterations=0, plot_eval_sets_error=True)
+    if path_boost.parameters_variable_importance is not None and hasattr(path_boost, 'variable_importance_'):
+        path_boost.plot_variable_importance(top_n_features=10)
+    else:
+        print("Variable importance not computed or available.")
+
+    print("Example run finished.")
+
+```
+
+## API Overview
+
+### PathBoost
+
+- `fit(X, y, anchor_nodes_label_name, list_anchor_nodes_labels, eval_set=None)`
+- `predict(X)`
+- `predict_step_by_step(X)`
+- `evaluate(X, y)`
+- `plot_training_and_eval_errors(skip_first_n_iterations=True)`
+- `plot_variable_importance()`
+- **Attributes:**
+  - `train_mse_`: Training error (MSE) at each iteration
+  - `mse_eval_set_`: Evaluation set error (MSE) at each iteration (if `eval_set` is provided)
+  - `variable_importance_`: Variable/path importance scores (if enabled)
+  - `is_fitted_`: Whether the model is fitted
+  - `models_list_`: List of fitted SequentialPathBoost models (one per anchor node)
+  - (Each SequentialPathBoost in `models_list_` exposes the attributes below)
+
+### SequentialPathBoost
+
+- `fit(X, y, list_anchor_nodes_labels, name_of_label_attribute, eval_set=None)`
+- `predict(X)`
+- `predict_step_by_step(X)`
+- `evaluate(X, y)`
+- `plot_training_and_eval_errors(skip_first_n_iterations=True)`
+- `plot_variable_importance()`
+- **Attributes:**
+  - `train_mse_`: Training error (MSE) at each iteration
+  - `train_mae_`: Training MAE at each iteration
+  - `eval_sets_mse_`: Evaluation set error (MSE) at each iteration (if `eval_set` is provided)
+  - `eval_sets_mae_`: Evaluation set MAE at each iteration (if `eval_set` is provided)
+  - `variable_importance_`: Variable/path importance scores (if enabled)
+  - `paths_selected_by_epb_`: Set of selected paths during boosting
+  - `columns_names_`: Names of EBM columns/features used
+  - `is_fitted_`: Whether the model is fitted
+
+## Requirements
+
+- Python 3.10+
+- numpy
+- pandas
+- scikit-learn
+- networkx
+- matplotlib
+
+(See `requirements.txt` for the full list.)
+
+## Citation
+
+If you use this library in your research, please cite the corresponding paper (add citation here).
+
+## License
+
+BSD 3-Clause License

path_boost-2.1.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+path_boost/__init__.py,sha256=DJGVzv6WAkNXzYPAR4bLOP3Doa774hSHFDLj9dxP9fg,427
+path_boost/_path_boost.py,sha256=4R0ZaoPApvxRiWhrlo1oTY7onedgiMMkdvU608EVs-g,43791
+path_boost/_version.py,sha256=v9WVy_5yL3epBJmMyIAo86Fa1LzYly1fPB2fENrVANg,520
+path_boost/utils/__init__.py,sha256=OLs978IP7BWkfydS9GzMQg4oPPAsQl9dEfxS2iQD9nI,67
+path_boost/utils/cross_validation.py,sha256=kXslG2reDePdn4a0wtsHKDiOI7iW0xWGlz0XPqG3Y78,1467
+path_boost/utils/cyclic_path_boost_utils.py,sha256=2--3OflOIDfqtT94nGmukScJGDdO77yU3ldUUeGfHmM,2843
+path_boost/utils/discovery.py,sha256=fB7nHL8qQLoGJBuWtpqDr8ylvg_A6rRYy4z0EZXaWu8,7136
+path_boost/utils/plots_functions.py,sha256=rKr9cQlnrZbwL42D-NMRgvuZq0LFuBMe4wYpq-1pMSw,5233
+path_boost/utils/validate_data.py,sha256=wMILdnJaPys945VDN9LKJa5Tg7f1TaUrDgV6rReK_RI,8916
+path_boost/utils/variable_importance_according_to_path_boost.py,sha256=BSsyyW43wxrl03pK6HHuTlSxh9UK7vqmCOP2oQsIQhg,15037
+path_boost/utils/classes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+path_boost/utils/classes/additive_model_wrapper.py,sha256=WjWhzVAPrR7TrK92IrSeuP-xxi_SY3KfWx44kWcqmNk,10930
+path_boost/utils/classes/additive_model_wrapper_classifier.py,sha256=D6vJ8Q7qEglayqlnL_3XD7HpSCfGJeTjHOA57R6UfE4,15044
+path_boost/utils/classes/extended_boosting_matrix.py,sha256=wXzZkGsrlfOyUyvun7M__JCk_k2rJLL5a80ayIJ_sJY,23716
+path_boost/utils/classes/sequential_path_boost.py,sha256=uXHVUaUC-J8_9_lppNczSUvHsfaiaDWfshCemC1ah2E,43544
+path_boost/utils/classes/sequential_path_boost_classifier.py,sha256=_cDWLdIrxpi2hps6W-0mxYPiAQ9r5rLIbQ2U4VbpJSI,35659
+path_boost/utils/classes/interfaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+path_boost/utils/classes/interfaces/interface_base_learner.py,sha256=PtYXYMoknCn6U-0Bl_7hFo3DX-_830D1WuY9PH5jD3c,818
+path_boost/utils/classes/interfaces/interface_selector.py,sha256=1xuCsgIwj5-6mU27R6mQLQWmqpgFj197UzIWwt-RQV0,673
+path_boost/utils/datasets_for_examples/__init__.py,sha256=OLs978IP7BWkfydS9GzMQg4oPPAsQl9dEfxS2iQD9nI,67
+path_boost/utils/datasets_for_examples/generate_example_dataset.py,sha256=gtHOyRYEWN5pT-LQZoHvvaWhmpnWcQ6s01UklJJKzgY,11929
+path_boost-2.1.0.dist-info/licenses/LICENSE,sha256=oaQgL_11JDZk4U2flY7eCLcjXqHuVp0H9Novv7PrsV0,1092
+path_boost-2.1.0.dist-info/METADATA,sha256=Ih3nwPzYMlS9Ym3upZP3-17GXk9dvFT2FEtUO_KqOlc,6147
+path_boost-2.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+path_boost-2.1.0.dist-info/top_level.txt,sha256=Cz9AC5j1bERLpvkxax55nUSGy7G7g2HjbUO-XOxQ2Zs,11
+path_boost-2.1.0.dist-info/RECORD,,

path_boost-2.1.0.dist-info/WHEEL

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

path_boost-2.1.0.dist-info/licenses/LICENSE

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

path_boost-2.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+path_boost