cutpointpy 1.0.0__py3-none-any.whl

cutpointpy/core.py

@@ -0,0 +1,457 @@
+from abc import ABC, abstractmethod
+from itertools import product
+import numpy as np
+from sklearn.model_selection import StratifiedShuffleSplit
+
+from cutpointpy.utils import auc as area_under_curve,\
+     check_same_length, cm, cm_performance_metrics
+
+class CutpointCalculator():
+    """
+    Performs optimal cut-point calculation and bootstrapping.
+    """
+    
+    def __init__(self, target='youdenj', polarity=True, 
+                 interpolation=None, num_points=100):
+        """
+        Parameters
+        ----------
+        target : str
+            The target function to maximise or minimise. 
+            Possible values:
+                'youdenj' -> see `Youdenj` class documentation.
+                'eucdist' -> see `Eucdist` class documentation.
+        polarity : bool
+            The direction of the inequality. If True (False) the 
+            datapoints with feature value greater (less) than or equal 
+            to the threshold are flagged as positive and the other ones 
+            as negative.
+        interpolation : str [optional]
+            Interpolation method for generating the set of thresholds
+            to test. Possible values:
+                None     -> No interpolation is used. The optimal 
+                            cut-point is chosen among the feature 
+                            values.
+                'linear' -> Thresholds are generated by linear
+                            interpolation between the min and max value 
+                            of `features`.
+        num_points : unsigned int [optional]
+            Number of thresholds generated. Has no effect if `interpolation`
+            is None.
+        """
+        
+        match target:
+            case 'eucdist':
+                self.optimal_cpcalculator = Eucdist()
+            case 'youdenj':
+                self.optimal_cpcalculator = Youdenj()
+            case _:
+                raise ValueError(f'Target `{target}` not recognised.')
+                
+        self.above = polarity
+        self.interpolation = interpolation
+        self.num_points = num_points
+            
+    def find(self, features, labels):
+        """
+        Determine the optimal cut-point value of a predictor variable 
+        (feature) for a binary classification task.
+            
+        Parameters
+        ----------
+        features : array-like of numeric (n_samples)
+            Value of the predictor variable for each datapoint. 
+            It is converted to an ndarray of float internally.
+        labels : array-like of numeric (n_samples)
+            Class label of each datapoint, where 0 indicates negative 
+            and any other value positive. It is converted to an ndarray of 
+            bool internally.
+   
+        Returns
+        -------
+        cutpoint : float
+            The optimal cut-point value.
+        cutpoint_idx : int
+            The index corresponding to the optimal cut-point value
+            among the thresholds tested.
+        thresholds : ndarray of numeric (N,1)
+            The thresholds tested. N = len(features) if 
+            `self.interpolation` is None, otherwise N = num_points.
+        acc : ndarray of numeric (N,1)
+            Accuracy as a function of the thresholds.
+        se : ndarray of numeric (N,1)
+            Sensitivity as a function of the thresholds.
+        sp : ndarray of numeric (N,1)
+            Specificity as a function of the thresholds.
+        auc : float
+            The area under the receiver-operating characteristic (ROC) 
+            curve.
+         
+        References
+        ----------
+        1. Hassanzad and Haijan-Tilaki (2024) 
+           doi:10.1186/s12874-024-02198-2 
+        """
+                
+        if not check_same_length(features, labels):
+            raise ValueError('There should be as many features as '
+                             'labels')
+            
+        #Labels and features: cast and reshape
+        features, labels = self._cast_and_reshape(features, labels)
+                
+        #Sort datapoints in ascending order by feature value
+        sorted_idxs = np.argsort(features, axis=0)
+        features, labels =\
+            [np.take_along_axis(x, sorted_idxs, axis=0) for x in 
+             [features, labels]]
+                
+        #Define the set of thresholds to test
+        if self.interpolation:
+                    
+            lingrid = np.linspace(start=np.min(features[:, 0]),
+                                  stop=np.max(features[:, 0]),
+                                  num=self.num_points)
+                    
+            match self.interpolation:
+                case 'linear':
+                    thresholds = np.interp(
+                        x=lingrid, xp=features[:, 0], fp=features[:, 0])
+                case _:
+                    raise ValueError(f'Interpolation "{interpolation}" '
+                                     f'not recognised')
+            
+            thresholds.shape = (thresholds.size, 1)
+        else:
+            thresholds = features
+                    
+        acc, se, sp, cutpoint, cutpoint_idx, auc =\
+            self._test_cutoff_values(
+                features=features, 
+                labels=labels, 
+                thresholds=thresholds,
+            )
+                            
+        return cutpoint, cutpoint_idx, thresholds, acc, se, sp, auc
+    
+    def bootstrap(self, features, labels, method='sss', train_ratio=0.7, 
+                  num_reps=30, random_state=0):
+        """
+        Compute/validate optimal cut-point through bootstrapping.
+        
+        Parameters
+        ----------
+        features : array-like of numeric (n_samples)
+            Value of the predictor variable for each datapoint. It is 
+            converted to ndarray of float internally.
+        labels : array-like of numeric (n_samples)
+            Class label of each datapoint, where 0 indicates negative 
+            and any other value positive. It is converted to ndarray of 
+            bool internally.
+        method : str
+            The strategy for generating the bootstratp repetitions-i.e.,
+            the subdivisions of the original data into train (in-bag
+            data) and test set (out-of-bag data).
+            Possible values:
+                `sss` -> Stratified shuffle split
+        train_ratio : float [0.0, 1.0]
+            The proportion of the original data used to generate the 
+            train set at each repetition.
+        num_reps : int
+            Number of bootstrap repetitions (i.e., number of 
+            subdivisions into train and test set).
+        random_state : int
+            Controls the randomness of the repetitions produced. Pass 
+            an int for reproducible output across multiple function 
+            calls, None for non-reproducible output.
+            
+        Returns
+        -------
+        cutpoints : ndarray of float (num_reps, 1)
+            The optimal cut-point value for each repetition estimated 
+            on the train set.
+        cutpoints_idxs : ndarray of float (num_reps, 1)
+            For each repetition the index of the `thresholds` array that
+            corresponds to the optimal cut-point.
+        thresholds : ndarray of float (num_reps, N)
+            The values of the thresholds tested on the train set at each
+            repetition. Element [i,j] of the matrix represents the j-th
+            threshold value for repetition i. 
+            N = floor(len(`features`) * `train_ratio`) if
+            `self.interpolation` is None, otherwise N =
+            `self.num_points`.
+        accs : ndarray of float (num_reps, N)
+            Accuracy on the train set for each repetition and threshold
+            value tested. 
+        ses : ndarray of float (num_reps, N)
+            Sensitivity on the train set for each repetition and
+            threshold value tested.
+        sps : ndarray of float (num_reps, N)
+            Specificity on the train set for each repetition and
+            threshold value tested.    
+        aucs_train : ndarray of float (num_reps, 1)
+            The area under the curve estimated on the train set for each
+            repetition .
+        aucs_test : ndarray of float (num_reps, 1)
+            The area under the curve estimated on the test set for each
+            repetition .
+        performance_train : ndarray of float (num_reps, 3)
+            For each repetition, in column-wise order, respectively 
+            accuracy, sensitivity and specificity yielded by the optimal
+            cut-point value when applied to the train set.
+        performance_test : ndarray of float (num_reps, 3)
+            For each repetition, in column-wise order, respectively
+            accuracy, sensitivity and specificity yielded by the optimal
+            cut-point value when applied to the test set.
+        performance_whole : ndarray of float (num_reps, 3)
+            For each repetition, in column-wise order, respectively
+            accuracy, sensitivity and specificity yielded by the optimal
+            cut-point value when applied to the whole dataset.
+        """
+        
+        features, labels = self._cast_and_reshape(features, labels)
+        
+        #===============================================================
+        #================ Initialise the output ========================
+        #===============================================================
+        cutpoints, cutpoints_idxs, aucs_train, aucs_test =\
+            [np.zeros(shape=(num_reps,1), dtype=float) for _ in range(4)]
+        performance_train, performance_test, performance_whole =\
+            [np.zeros(shape=(num_reps,3), dtype=float) for _ in range(3)]
+        
+        if self.interpolation:
+            num_thresholds = self.num_points
+        else:
+            num_thresholds = np.floor(
+                len(features) * train_ratio, 
+                dtype=int, casting='unsafe'
+            )
+            
+        thresholds, accs, ses, sps = \
+            [np.zeros(shape=(num_reps, num_thresholds), dtype=float) 
+             for _ in range(4)]
+        #===============================================================
+        #===============================================================
+        #===============================================================
+        
+        
+        match method:
+            case 'sss':
+                splitter = StratifiedShuffleSplit(
+                    n_splits=num_reps, 
+                    train_size=train_ratio, 
+                    random_state=random_state
+                )
+            case _:
+                raise ValueError(f'Unrecognised method `{method}`.')
+            
+        for split_idx, (train_idxs, test_idxs) in enumerate(
+            splitter.split(X=features, y=labels)):
+                        
+            train_features, test_features, train_labels, test_labels = \
+                [container[idxs] for container, idxs in 
+                 product((features, labels), (train_idxs, test_idxs))]
+            
+            #===========================================================
+            #==== Return values computed on the train (in bag) data ====
+            #===========================================================
+            cutpoint, cutpoint_idx, thresholds_, acc, se, sp, auc =\
+                self.find(train_features, train_labels)
+            
+            for out_, in_ in zip((cutpoints, cutpoints_idxs), 
+                                 (cutpoint, cutpoint_idx)):
+                out_[split_idx] = in_            
+                        
+            for out_, in_ in zip((thresholds, accs, ses, sps), 
+                                 (thresholds_, acc, se, sp)):
+                out_[split_idx,:] = in_.flat
+            
+            for i, in_ in enumerate([acc, se, sp]):
+                performance_train[split_idx, i] = in_[cutpoint_idx,0]
+            
+            aucs_train[split_idx,0] = auc
+            #===========================================================
+            #===========================================================
+            #===========================================================
+            
+            #Compute auc on the test set
+            _, _, _, _, _, _, aucs_test[split_idx,0] =\
+                self.find(test_features, test_labels)            
+            
+            #Compute performance parameters on the test set using the 
+            #cut-point value estimated on the train set
+            acc, se, sp, _, _, _ = self._test_cutoff_values(
+                features=test_features, 
+                labels=test_labels, 
+                thresholds = np.array(cutpoint, ndmin=2), 
+            )
+            for i, in_ in enumerate([acc, se, sp]):
+                performance_test[split_idx, i] = in_[0,0]            
+            
+            #Compute performance parameters on the whole dataset using 
+            #the cut-point value estimated on the train set
+            acc, se, sp, _, _, _ = self._test_cutoff_values(
+                features=features, 
+                labels=labels, 
+                thresholds = np.array(cutpoint, ndmin=2), 
+            )
+            for i, in_ in enumerate([acc, se, sp]):
+                performance_whole[split_idx, i] = in_[0,0]      
+            
+        return cutpoints, cutpoints_idxs, thresholds, accs, ses, sps,\
+               aucs_train, aucs_test, performance_train,\
+               performance_test, performance_whole        
+
+    def _test_cutoff_values(self, features, labels, thresholds):
+        """
+        Classification performance of a set of cut-off values
+        (thresholds) when applied to a predictor variable (feature) for
+        a binary classification task.
+    
+        Parameters
+        ----------
+        features : ndarray of float (n_features, 1)
+            Value of the predictor variable for each datapoint. 
+        labels : ndarray of bool (n_features, 1)
+            Class label of each datapoint, where True indicates the
+            positive class.
+        thresholds : ndarray of float (n_thresholds, 1)
+            The cut-off values to be tested, sorted in ascending order.
+        
+        Returns
+        -------
+        acc, se, sp : ndarrays of float, each of shape (n_thresholds, 1)
+            Accuracy, sensitivity and pecificity as a function of the 
+            cut-off value.
+        cutpoint : float    
+            The optimal cut-off value.
+        cutpoint_idx : int [0, (n_thresholds - 1)]
+            Index of the optimal cut-off value.
+        auc : float
+            The area under the curve.
+        """
+    
+        #Reshape features and thresholds for vectorisation. 
+        #Prepend 'r_' to indicate the reshaped versions
+        r_features = np.tile(features.T, reps=(thresholds.size, 1))
+        r_thresholds = np.tile(thresholds, reps=(1, features.size))
+
+        #Predict labels as a function of threshold
+        if self.above:
+            predicted = (r_features >= r_thresholds)
+        else:
+            predicted = (r_features <= r_thresholds)
+    
+        #Compute sensitivity and specificity as a function of threshold
+        confmat = cm(predicted=predicted,
+                     target=np.tile(labels.T, reps=(thresholds.size, 1)))
+        acc, se, sp = cm_performance_metrics(confmat)
+    
+        #Compute optimal cutpoint
+        cutpoint, cutpoint_idx = self.optimal_cpcalculator.find(
+            thresholds=thresholds, se=se, sp=sp
+        )
+    
+        #Compute AUC
+        auc = area_under_curve(se=se.T, sp=sp.T).flatten()[0]
+    
+        return acc, se, sp, cutpoint, cutpoint_idx, auc
+    
+    @staticmethod
+    def _cast_and_reshape(features, labels):
+        """
+        Convert and reshape features and labels to ndarray.
+        
+        Parameters
+        ----------
+        features : array-like of numeric (n_samples)
+            Value of the predictor variable for each datapoint. 
+        labels : array-like of numeric (n_samples)
+            Class label of each datapoint, where 0 indicates negative 
+            and any other value positive.
+            
+        Returns
+        -------
+        features : ndarray of float (n_samples, 1)
+            Cast and reshaped features.
+        labels : ndarray of bool (n_samples, 1)
+            Cast and reshaped labels.
+        """
+        
+        check_same_length(features, labels)
+         
+        features = np.array(features, dtype=float, ndmin=2)
+        labels = np.array(labels, dtype=bool, ndmin=2)
+        
+        for item in [features, labels]:
+            item.shape = (features.size, 1)
+        
+        return features, labels
+    
+    
+    
+class OptimalCutpointCalculator(ABC):
+    """
+    Encapsulates the target function to maximise or minimise. 
+    """
+    
+    @staticmethod
+    @abstractmethod
+    def find(thresholds, se, sp):
+        """
+        Determine the optimal cut-point given sensitivity and specificity as a
+        function of the thresholds tested.
+    
+        Parameters
+        ----------
+        thresholds : ndarray of float (N,1)
+            The set of thresholds to test, sorted from smallest to 
+            largest.
+        se : ndarray of float (N,1)
+            Sensitivity as a function of the threshold.
+        sp : ndarray of float (N,1)
+            Specificity as a function of the threshold.
+                         
+        Returns
+        -------
+        cutpoint : numeric
+            The optimal cut-point value.
+        cutpoint_idx : int
+            The index corresponding to optimal cut-point value.
+        """
+        pass
+    
+class Youdenj(OptimalCutpointCalculator):
+    """
+    Maximises Youden’s J - i.e.: Sensitivity + Specificity - 1.
+    """
+    
+    @staticmethod
+    def find(thresholds, se, sp):
+        """
+        Note
+        ----
+        If the maximum occurrs on multiple values of threshold the first
+        (smallest) occurrence is returned.
+        """
+        target_values = se + sp - 1
+        idx = np.argmax(target_values, axis=0).flatten()[0]
+        return thresholds[idx, 0], idx
+    
+class Eucdist(OptimalCutpointCalculator):
+    """
+    Minimises the Euclidean distance between the (0,1) point and the ROC curve
+    in the FPR (1 - sp) vs. TPR (se) space.
+    """
+    
+    @staticmethod
+    def find(thresholds, se, sp):
+        """
+        Note
+        ----
+        If the minimum occurrs on multiple values of threshold the last
+        (largest) occurrence is returned.
+        """        
+        target_values = np.sqrt((1 - se)**2 + (1 - sp)**2)
+        idx = np.argmin(target_values, axis=0).flatten()[-1]
+        return thresholds[idx, 0], idx

cutpointpy/utils.py

@@ -0,0 +1,143 @@
+import numpy as np
+
+def check_same_length(*args):
+    """
+    Check if iterables have the same length.
+    
+    Parameters
+    ----------
+    args :
+        The iterables to be compared for equal length.
+        
+    Returns
+    -------
+    same_length : bool
+        True if all `àrgs` have the same length, False otherwise.
+    """
+    if not (len(args) > 1):
+        raise ValueError('At least two iterables should be given.')
+
+    first_len = len(args[0])
+    same_length = all(len(arg) == first_len for arg in args)
+    
+    return same_length
+
+def cm(predicted, target):
+    """
+    Confusion matrix for a binary outcome.
+    
+    Parameters
+    ----------
+    predicted : ndarray of bool (n_tests, n_samples)
+        The predicted labels.
+    target : ndarray of bool (n_tests, n_samples)
+        The target labels (ground truth).
+                       
+    Returns
+    -------
+    cm : ndarray of bool (n_tests, 4)
+        The confusion matrices. Each row represents one matrix; columns
+        0 to 3 respectively report the number of true positives, false
+        negatives, false positives and true negatives.
+        
+    Notes
+    -----
+    Vectorised function - computes n_tests confusion matrices at once.
+    Convention for labels: True denotes the positive class.
+    """
+    
+    if not (predicted.shape == target.shape):
+        raise ValueError('Predicted and target values must have the'
+                         'same shape')
+
+    cm = np.zeros(shape=(predicted.shape[0], 4), dtype=np.uint)
+
+    cm[:, 0] = np.sum(np.equal(predicted, True)
+                      & np.equal(target, True), axis=1)
+    cm[:, 1] = np.sum(np.equal(predicted, False)
+                      & np.equal(target, True), axis=1)
+    cm[:, 2] = np.sum(np.equal(predicted, True)
+                      & np.equal(target, False), axis=1)
+    cm[:, 3] = np.sum(np.equal(predicted, False)
+                      & np.equal(target, False), axis=1)
+    
+    return cm
+
+def cm_performance_metrics(cm):
+    """
+    Performance metrics from the confusion matrix.
+    
+    Parameters
+    ----------
+    cm : ndarray of bool (n_matrices, 4)
+        The confusion matrices. Each row represents one matrix; columns
+        0 to 3 respectively report the number of true positives, false
+        negatives, false positives and true negatives.
+        
+    Returns
+    -------
+    acc : ndarray of float (n_matrices, 1)
+        Accuracy.
+    se : ndarray of float (n_matrices, 1)
+        Sensitivity.
+    sp : ndarray of float (n_matrices, 1)
+        Specificity.
+        
+    Notes
+    -----
+    Returned values are for each confusion matrix. Accuracy, sensitivity
+    and specificity range between 0.0 and 1.0.
+    """
+    
+    acc = (cm[:, 0] + cm[:, 3]) / np.sum(cm, axis=1)
+    se = cm[:, 0] / (cm[:, 0] + cm[:, 1])
+    sn = cm[:, 3] / (cm[:, 3] + cm[:, 2])
+    
+    retval = list()
+    for item in [acc, se, sn]:
+        retval.append(np.array(item, ndmin=2).T)
+    
+    return retval
+
+def auc(se, sp):
+    """
+    Compute the area under the Receiver-operating characteristic (ROC) 
+    curve.
+    
+    Parameters
+    ----------
+    se : ndarray of numeric (n_tests, n_thresholds)
+        Sensitivity as a function of the thresholds.
+    sp : ndarray of numeric (n_tests, n_thresholds)
+        Specificity as a function of the thresholds.
+        
+    Returns
+    -------
+    auc : float (n_tests, 1)
+        The areas under the curve.
+    
+    Notes
+    -----
+    1.    Vectorised function, computes n_tests AUCs at once.
+    2.    It is assumed that in each row `se` and `sp` are matched by 
+          threshold value. That is, for each row of `se` and `sp` 
+          the same column index corresponds to the same threshold value.
+    3.    Area calculation is based on the trapezoidal rule.
+    """
+
+    if not (se.shape == sp.shape):
+        raise ValueError(f'`se` and `sp` must have the same shape')
+
+    #Compute true positive rate (TPR) and false positive rate (FPR)
+    tpr = se
+    fpr = 1 - sp
+
+    #Sort by FPR in increasing order
+    sorted_idxs = np.argsort(fpr)
+    tpr = np.take_along_axis(tpr, sorted_idxs)
+    fpr = np.take_along_axis(fpr, sorted_idxs)
+
+    #Compute AUC
+    auc = np.array(np.trapezoid(y=tpr, x=fpr), ndmin=2).T
+
+    return auc

cutpointpy-1.0.0.dist-info/METADATA

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: cutpointpy
+Version: 1.0.0
+Summary: Optimal cut-point calculation of a predictor variable for binary classification tasks
+Author-email: Francesco Bianconi <bianco@ieee.org>
+License-Expression: GPL-3.0-or-later
+Project-URL: home, https://github.com/bianconif/cutpointpy
+Project-URL: repository, https://github.com/bianconif/cutpointpy
+Keywords: binary-classification,cut-point,roc-analysis,sensitivity,specificity
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scikit-learn
+Dynamic: license-file
+
+# cutpointpy
+____________
+A Python package for estimating the optimal cut-point of a predictor variable (feature) for a binary classification task. It is loosely inspired by [`cutpointr`](https://cran.r-project.org/web/packages/cutpointr/index.html), an optimal cut-point calculation package for [R](https://www.r-project.org/).
+
+Main usage:
+
+ - Optimal cut-point estimation
+ - Stability analysis of the estimated cut-points through bootstrapping
+ - Receiver-operating characteristic curve (ROC) analysis  
+
+## Installation
+`pip install cutpointpy`
+
+## Structure
+  - `cutpointpy.core`: contains the main class (`CutpointCalculator`) with functions `find()` and `bootstrap()` respectively for optimal cut-point estimation and stability analysis/validation through bootstrapping.
+  - `cutpointpy.utils`: contains ancillary functions including methods for computing performance parameters on binary classification tasks (e.g. confusion matrices, accuracy, sensitivity, specificity and AUC)
+
+## Usage
+We recommend the following [marimo](https://marimo.io/) notebooks to get started with `cutpointpy`.
+- Optimal cut-point estimation without bootstrapping
+    * [cutpointfind__glucose_cutoff_for_diabetes.py](https://molab.marimo.io/notebooks/nb_P81opF6FjJpcwDeycTAVDb)
+    * [cutpointfind__ibmi_cutoff_for_diabetes.py](https://molab.marimo.io/notebooks/nb_D5qnT3WHLxrNVpFtwxBHpc)
+- Optimal cut-point estimation with bootstrapping
+    * [cutpointboot__glucose_cutoff_for_diabetes.py](https://molab.marimo.io/notebooks/nb_ZxGQFfmRsEBb5LRq8hqrXo)
+
+
+## References
+1. Baratloo, A., Hosseini, M., Negida, A., El Ashal, G. [Part 1: simple definition and calculation of accuracy, sensitivity and specificity](https://pmc.ncbi.nlm.nih.gov/articles/PMC4614595/) (2015) Emergency 3(2):48-49
+2. Hassanzad M., Hajian-Tilaki K. [Methods of determining optimal cut-point of diagnostic biomarkers with application of clinical data in ROC analysis: an update review](https://doi.org/10.1186/s12874-024-02198-2) (2024) BMC Medical Research Methodology, 24(1), art. no. 84
+
+## Contacts
+[Francesco Bianconi](www.bianconif.net) - [bianco@ieee.org](mailto:bianco@ieee.org).

cutpointpy-1.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+cutpointpy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cutpointpy/core.py,sha256=ezQJ8kNqm9d4oihMCcLcasY5dYTq8mYl5fgDYpxfcU4,19069
+cutpointpy/utils.py,sha256=cxTrtTNczIlR0bN7k00_NUyk8WzVX1iM6Sdn80afRhc,4388
+cutpointpy-1.0.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+cutpointpy-1.0.0.dist-info/METADATA,sha256=F_8i-E2Jbuv40y-If6dT4GuF76wGX8BQiixXGrqMJJg,2793
+cutpointpy-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+cutpointpy-1.0.0.dist-info/scm_file_list.json,sha256=_HvuVUKfgFObfnhdLVfPaIk0jTiA5d3Ltm6-PexJj3s,309
+cutpointpy-1.0.0.dist-info/scm_version.json,sha256=TxlYJP0Qs8Unv1JgWlv37F6xrY7Vxxg4YztqiSm6_z4,170
+cutpointpy-1.0.0.dist-info/top_level.txt,sha256=kHAUPkGYJmDf_OsRAsBsIOC6VYr2nDvSPEk5fjPZbLw,11
+cutpointpy-1.0.0.dist-info/RECORD,,

cutpointpy-1.0.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
+