orangeplsda 0.1.0__py3-none-any.whl

orangeplsda/__init__.py

@@ -0,0 +1,10 @@
+"""
+orangeplsda - PLS-DA (Partial Least Squares Discriminant Analysis) for Orange3.
+
+Provides a classification learner and widget for PLS-DA.
+"""
+
+from .plsda_learner import PLSDALearner, PLSDAModel
+from .oplsda_learner import OPLSDALearner, OPLSDAModel
+
+__all__ = ["PLSDALearner", "PLSDAModel", "OPLSDALearner", "OPLSDAModel"]

orangeplsda/oplsda_learner.py

@@ -0,0 +1,324 @@
+"""
+OPLS-DA (Orthogonal Partial Least Squares Discriminant Analysis)
+learner and model.
+
+OPLS-DA separates predictive (class-correlated) from orthogonal
+(class-uncorrelated) variation in X, producing clearer interpretation
+for biomarker discovery. Implements the Trygg & Wold (2002) algorithm.
+
+The model fits orthogonal components via NIPALS-style deflation, then
+extracts the predictive component. The S-Plot (Wiklund et al., 2008)
+is derived from the predictive loadings and correlations.
+"""
+
+import numpy as np
+from Orange.base import Learner
+from Orange.classification.base_classification import (
+    SklLearnerClassification, SklModelClassification,
+)
+
+__all__ = ["OPLSDAModel", "OPLDALearner"]
+
+
+class OPLSDAModel(SklModelClassification):
+    """OPLS-DA classification model.
+
+    Wraps the fitted OPLS parameters (predictive + orthogonal) and
+    provides predictions, projections, and S-Plot data.
+    """
+    supports_multiclass = True
+
+    def __init__(self, skl_model):
+        # The "skl_model" attribute is used by SklModel for domain
+        # handling, but we don't use sklearn here — store it as None
+        # and put our real parameters in custom attributes.
+        super().__init__(skl_model)
+        self.n_predictive = 0
+        self.n_ortho = 0
+        # predictive
+        self.w_pred = None       # (n_features, 1)
+        self.p_pred = None       # (n_features, 1)
+        self.t_pred_mean = 0.0   # mean of training t_pred
+        self.t_pred_std = 1.0
+        # orthogonal per component
+        self.w_ortho = []        # list of (n_features, 1) vectors
+        self.p_ortho = []        # list of (n_features, 1) vectors
+        # scaling
+        self.x_mean = None
+        self.x_std = None
+        self.y_mean = None
+        self.y_std = None
+        self.scaled = False
+        # class info
+        self.classes = None
+        self.n_classes = 0
+        # raw Y predictions for probability computation
+        self.y_pred_model = None  # PLS regression model (fitted on deflated X)
+
+    def _deflate(self, X):
+        """Apply orthogonal deflation to new X."""
+        Xd = X.copy()
+        for i in range(self.n_ortho):
+            t_o = Xd @ self.w_ortho[i].ravel()
+            Xd -= np.outer(t_o, self.p_ortho[i].ravel())
+        return Xd
+
+    def _predict_raw(self, X):
+        """Compute raw Y scores (predictive Y response)."""
+        if self.scaled and self.x_mean is not None:
+            Xc = (X - self.x_mean) / self.x_std
+        else:
+            Xc = X.copy()
+        # deflate
+        Xd = self._deflate(Xc)
+        # predictive score
+        t_pred = Xd @ self.w_pred.ravel()
+        # project through the PLS model
+        y_pred = self.y_pred_model.predict(Xd)
+        # unscale Y
+        if self.scaled and self.y_std is not None:
+            y_pred = y_pred * self.y_std + self.y_mean
+        return y_pred
+
+    def predict(self, X):
+        """Predict class labels and probabilities.
+
+        Returns a tuple (values, probs) where:
+        - values: integer class indices (argmax of raw Y scores)
+        - probs: softmax-transformed class probabilities
+        """
+        y_raw = self._predict_raw(X)
+        if y_raw.ndim == 1:
+            y_raw = y_raw.reshape(-1, 1)
+        values = np.argmax(y_raw, axis=1).astype(float)
+        # softmax for probabilities
+        y_max = y_raw.max(axis=1, keepdims=True)
+        exp_s = np.exp(y_raw - y_max)
+        probs = exp_s / exp_s.sum(axis=1, keepdims=True)
+        return values, probs
+
+    def __str__(self):
+        return f"OPLSDAModel(n_pred={self.n_predictive}, n_ortho={self.n_ortho})"
+
+    def get_splot(self):
+        """Return S-Plot coordinates (p and pcorr) for the predictive
+        component.
+
+        Returns
+        -------
+        p : ndarray (n_features,)
+            Covariance loading (predictive loading p_pred)
+        pcorr : ndarray (n_features,)
+            Correlation loading: corr(X_j, t_pred)
+        scores : ndarray (n_samples,)
+            Predictive scores t_pred for the training data
+        """
+        p = self.p_pred.ravel().copy()
+        # t_pred scores from training
+        scores = None  # not stored by default, need to compute
+        return p, scores
+
+    def plot_data(self, X_train):
+        """Compute complete S-Plot data from training X.
+
+        Parameters
+        ----------
+        X_train : ndarray (n_samples, n_features)
+            The training data (original scale)
+
+        Returns
+        -------
+        p : ndarray (n_features,)
+        pcorr : ndarray (n_features,)
+        t_pred : ndarray (n_samples,)
+        """
+        if self.scaled and self.x_mean is not None:
+            Xc = (X_train - self.x_mean) / self.x_std
+        else:
+            Xc = X_train.copy()
+        Xd = self._deflate(Xc)
+        t_pred = Xd @ self.w_pred.ravel()
+
+        n = len(t_pred)
+        sd_t = np.std(t_pred, ddof=1)
+        sd_X = np.std(Xd, axis=0, ddof=1)
+
+        p = self.p_pred.ravel().copy()
+        # pcorr_j = p_j * sd(t_pred) / sd(X_j)
+        pcorr = np.where(sd_X > 1e-15, p * sd_t / sd_X, 0.0)
+        return p, pcorr, t_pred
+
+
+class OPLSDALearner(SklLearnerClassification):
+    """OPLS-DA (Orthogonal Partial Least Squares Discriminant Analysis)
+    learner.
+
+    Fits an OPLS model that separates predictive (class-correlated)
+    variation from orthogonal (class-uncorrelated) variation.
+
+    Parameters
+    ----------
+    n_components : int
+        Number of predictive PLS components (typically 1 for OPLS)
+    n_ortho : int
+        Number of orthogonal components to remove
+    scale : bool
+        Whether to autoscale X (unit variance) before fitting
+    max_iter : int
+        Maximum NIPALS iterations
+    """
+    __wraps__ = object  # dummy — no sklearn model
+    __returns__ = OPLSDAModel
+    supports_multiclass = True
+
+    def __init__(self, n_components=1, n_ortho=1, scale=True,
+                 max_iter=500, preprocessors=None):
+        super().__init__(preprocessors=preprocessors)
+        # NOTE: must set self._params (NOT self.params) — SklLearner.params is
+        # a property whose setter filters keys through __wraps__.__init__'s
+        # signature. Since __wraps__ = object here (pure-numpy learner), that
+        # filter drops every key, leaving params empty.
+        self._params = {
+            "n_components": n_components,
+            "n_ortho": n_ortho,
+            "scale": scale,
+            "max_iter": max_iter,
+        }
+
+    def _pls_first(self, X, Y):
+        """Compute the first PLS component of (X, Y) robustly.
+
+        Uses sklearn's PLSRegression which handles multivariate Y (one-hot
+        class indicators) correctly. Returns the weight, score, X-loading and
+        Y-loading vectors for the first component.
+
+        Returns
+        -------
+        w : ndarray (n_features,)
+        t : ndarray (n_samples,)
+        p : ndarray (n_features,)
+        c : ndarray (n_class,)
+        """
+        from sklearn.cross_decomposition import PLSRegression
+        pls = PLSRegression(n_components=1)
+        pls.fit(X, Y)
+        return (pls.x_weights_[:, 0].copy(),
+                pls.x_scores_[:, 0].copy(),
+                pls.x_loadings_[:, 0].copy(),
+                pls.y_loadings_[:, 0].copy())
+
+    def fit(self, X, Y, W=None):
+        """Fit the OPLS-DA model.
+
+        X : ndarray (n_samples, n_features)
+        Y : ndarray (n_samples,)  — discrete class labels (0, 1, 2, ...)
+        W : ignored
+        """
+        n_classes = len(np.unique(Y))
+        n_comp = self.params["n_components"]
+        n_ortho = self.params["n_ortho"]
+        do_scale = self.params["scale"]
+
+        # Clamp
+        n_comp = max(min(n_comp, X.shape[1], X.shape[0] - 1, n_classes), 1)
+        n_ortho = max(min(n_ortho, X.shape[1], X.shape[0] - 1), 0)
+
+        # One-hot encode Y
+        Y_enc = np.zeros((len(Y), n_classes))
+        for i, l in enumerate(Y):
+            Y_enc[i, int(l)] = 1.0
+
+        # Center / scale
+        x_mean = X.mean(axis=0)
+        x_std = np.std(X, axis=0, ddof=1)
+        x_std[x_std < 1e-15] = 1.0
+        y_mean = Y_enc.mean(axis=0)
+        y_std = np.std(Y_enc, axis=0, ddof=1)
+        y_std[y_std < 1e-15] = 1.0
+
+        Xc = (X - x_mean) / x_std if do_scale else X - x_mean
+        Yc = (Y_enc - y_mean) / y_std if do_scale else Y_enc - y_mean
+
+        model = OPLSDAModel(None)
+        model.x_mean = x_mean
+        model.x_std = x_std
+        model.y_mean = y_mean
+        model.y_std = y_std if do_scale else None
+        model.scaled = do_scale
+        model.classes = np.unique(Y)
+        model.n_classes = n_classes
+        model.n_predictive = n_comp
+        model.n_ortho = n_ortho
+
+        Xk = Xc.copy()
+        Yk = Yc.copy()
+
+        # For each orthogonal component: compute PLS direction, remove ortho
+        for _ in range(n_ortho):
+            w, t, p, c = self._pls_first(Xk, Yk)
+            # Orthogonal weight: w_ortho is p with w component removed
+            denom = w @ w + 1e-15
+            w_o = p - w * (w @ p) / denom
+            nw = np.linalg.norm(w_o)
+            if nw < 1e-15:
+                break
+            w_o = w_o / nw
+            t_o = Xk @ w_o
+            t2_o = t_o @ t_o
+            if t2_o < 1e-15:
+                break
+            p_o = Xk.T @ t_o / t2_o
+            Xk -= np.outer(t_o, p_o)
+            model.w_ortho.append(w_o)
+            model.p_ortho.append(p_o)
+
+        model.n_ortho = len(model.w_ortho)
+
+        # Final predictive component
+        w, t_pred, p, c = self._pls_first(Xk, Yk)
+        model.w_pred = w.reshape(-1, 1)
+        model.p_pred = p.reshape(-1, 1)
+
+        # Store a simple PLS model for Y prediction (on deflated X)
+        # We use the pseudo-inverse: B = (Xk'Xk)^{-1} Xk' Yk
+        try:
+            B = np.linalg.lstsq(Xk, Yk, rcond=None)[0]
+        except np.linalg.LinAlgError:
+            B = np.zeros((Xk.shape[1], Yk.shape[1]))
+        model.y_pred_model = _PLSWrapper(B)
+
+        # Training predictive scores (used for S-Plot)
+        model.t_pred_mean = float(np.mean(t_pred))
+        model.t_pred_std = float(np.std(t_pred, ddof=1))
+        if model.t_pred_std < 1e-15:
+            model.t_pred_std = 1.0
+
+        return model
+
+    def incompatibility_reason(self, domain):
+        reason = None
+        if not domain.has_discrete_class:
+            reason = "Categorical (discrete) class variable expected.\n" \
+                     "OPLS-DA requires a class variable, not numeric target."
+        elif len(domain.class_vars) > 1:
+            reason = "OPLS-DA supports only a single class variable."
+        return reason
+
+    @property
+    def fitted_parameters(self) -> list[Learner.FittedParameter]:
+        return [
+            self.FittedParameter("n_components", "Predictive comp.", int, 1, None),
+            self.FittedParameter("n_ortho", "Orthogonal comp.", int, 0, None),
+        ]
+
+    def __str__(self):
+        return f"OPLDALearner(pred={self.params['n_components']}, ortho={self.params['n_ortho']})"
+
+
+class _PLSWrapper:
+    """Minimal wrapper so the model can predict Y from deflated X."""
+    def __init__(self, B):
+        self.B = B
+
+    def predict(self, X):
+        return X @ self.B

orangeplsda/plsda_learner.py

@@ -0,0 +1,120 @@
+"""
+PLS-DA (Partial Least Squares Discriminant Analysis) learner and model.
+
+PLSDALearner wraps sklearn's PLSRegression for classification:
+1. One-hot encodes class targets (Y)
+2. Fits PLSRegression on the encoded targets
+3. Predicts by taking the argmax of regression outputs
+4. Provides probabilities via softmax transformation
+"""
+
+import numpy as np
+from sklearn.cross_decomposition import PLSRegression as SKLPLSRegression
+
+from Orange.base import Learner, SklLearner
+from Orange.classification.base_classification import (
+    SklLearnerClassification, SklModelClassification,
+)
+from Orange.data import DiscreteVariable
+
+
+__all__ = ["PLSDALearner", "PLSDAModel"]
+
+
+class PLSDAModel(SklModelClassification):
+    """PLS-DA classification model.
+
+    Wraps a fitted sklearn PLSRegression model. Prediction is done by taking
+    the argmax of the continuous regression outputs. Probabilities are
+    derived via softmax.
+    """
+
+    supports_multiclass = True
+
+    def predict(self, X):
+        """Predict class labels and probabilities.
+
+        Returns a tuple (values, probs) where:
+        - values: integer class indices (argmax of regression outputs)
+        - probs: softmax-transformed class probabilities
+        """
+        # PLSRegression predict returns n_samples x n_classes
+        raw_scores = self.skl_model.predict(X)
+
+        if raw_scores.ndim == 1:
+            raw_scores = raw_scores.reshape(-1, 1)
+
+        # Class predictions: argmax over classes
+        values = np.argmax(raw_scores, axis=1).astype(float)
+
+        # Probabilities via softmax
+        exp_scores = np.exp(raw_scores - raw_scores.max(axis=1, keepdims=True))
+        probs = exp_scores / exp_scores.sum(axis=1, keepdims=True)
+
+        return values, probs
+
+    def __str__(self):
+        return f"PLSDAModel(n_components={self.skl_model.n_components})"
+
+
+class PLSDALearner(SklLearnerClassification):
+    """PLS-DA (Partial Least Squares Discriminant Analysis) learner.
+
+    Uses sklearn's PLSRegression internally. For classification, the
+    discrete target is one-hot encoded into indicator variables, and the
+    regression is performed on those. Predictions are decoded back to class
+    labels via argmax.
+    """
+
+    __wraps__ = SKLPLSRegression
+    __returns__ = PLSDAModel
+    supports_multiclass = True
+
+    def fit(self, X, Y, W=None):
+        """Fit the PLS-DA model.
+
+        One-hot encodes the discrete class labels Y into indicator variables,
+        fits PLSRegression, and returns a PLSDAModel.
+        """
+        params = self.params.copy()
+        # Clamp n_components to feasible range
+        n_classes = len(np.unique(Y))
+        params["n_components"] = min(
+            X.shape[1], X.shape[0] - 1, n_classes, params["n_components"]
+        )
+        params["n_components"] = max(params["n_components"], 1)
+
+        # One-hot encode Y: n_samples x n_classes indicator matrix
+        Y_encoded = np.zeros((len(Y), n_classes))
+        for i, label in enumerate(Y):
+            Y_encoded[i, int(label)] = 1.0
+
+        clf = self.__wraps__(**params)
+        clf.fit(X, Y_encoded)
+        return self.__returns__(clf)
+
+    def __init__(self, n_components=2, scale=True, max_iter=500,
+                 preprocessors=None):
+        super().__init__(preprocessors=preprocessors)
+        self.params = vars()
+
+    def incompatibility_reason(self, domain):
+        """Check if the domain is compatible with PLS-DA."""
+        reason = None
+        if not domain.has_discrete_class:
+            reason = "Categorical (discrete) class variable expected.\n" \
+                     "PLS-DA requires a class variable, not a numeric target."
+        elif len(domain.class_vars) > 1:
+            reason = "PLS-DA supports only a single class variable."
+        return reason
+
+    @property
+    def fitted_parameters(self) -> list[Learner.FittedParameter]:
+        return [
+            self.FittedParameter(
+                "n_components", "Components", int, 1, None
+            )
+        ]
+
+    def __str__(self):
+        return f"PLSDALearner(n_components={self.params.get('n_components', 2)})"

orangeplsda/widgets/__init__.py

@@ -0,0 +1,8 @@
+"""
+Widget definitions for orangeplsda.
+"""
+
+from .owplsda import OWPLSDA
+from .owoplsda import OWOPLSDA
+
+__all__ = ["OWPLSDA", "OWOPLSDA"]

orangeplsda/widgets/icons/OPLSDA.svg

@@ -0,0 +1,11 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48">
+  <rect x="4" y="4" width="40" height="40" rx="6" fill="#E91E63"/>
+  <text font-family="Arial, sans-serif" font-size="8" font-weight="bold" fill="white" x="24" y="16" text-anchor="middle">OPLS</text>
+  <text font-family="Arial, sans-serif" font-size="8" fill="#F48FB1" x="24" y="30" text-anchor="middle">DA</text>
+  <line x1="8" y1="36" x2="40" y2="36" stroke="#FCE4EC" stroke-width="1" opacity="0.6"/>
+  <circle cx="14" cy="34" r="2" fill="#fff" opacity="0.8"/>
+  <circle cx="20" cy="30" r="2" fill="#fff" opacity="0.5"/>
+  <circle cx="28" cy="32" r="2" fill="#fff" opacity="0.5"/>
+  <circle cx="34" cy="28" r="2" fill="#fff" opacity="0.8"/>
+  <circle cx="24" cy="30" r="3" fill="#fff" opacity="0.9"/>
+</svg>

orangeplsda/widgets/icons/PLSDA.svg

@@ -0,0 +1,11 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48">
+  <defs>
+    <linearGradient id="g" x1="0" y1="0" x2="0" y2="1">
+      <stop offset="0%" stop-color="#2196F3"/>
+      <stop offset="100%" stop-color="#1565C0"/>
+    </linearGradient>
+  </defs>
+  <rect x="4" y="4" width="40" height="40" rx="6" fill="url(#g)"/>
+  <text font-family="Arial, sans-serif" font-size="14" font-weight="bold" fill="white" x="24" y="24" text-anchor="middle" dominant-baseline="central">PLS</text>
+  <text font-family="Arial, sans-serif" font-size="10" fill="#BBDEFB" x="24" y="36" text-anchor="middle" dominant-baseline="central">DA</text>
+</svg>

orangeplsda/widgets/owoplsda.py

@@ -0,0 +1,313 @@
+"""
+OWOPLSDA widget — OPLS-DA (Orthogonal Partial Least Squares
+Discriminant Analysis) with S-Plot for biomarker discovery.
+
+Separates predictive from orthogonal variation and provides
+an S-Plot visualization for variable selection.
+"""
+
+import numpy as np
+from AnyQt.QtCore import Qt
+from AnyQt.QtGui import QColor, QPen
+
+import pyqtgraph as pg
+from pyqtgraph import PlotWidget
+
+from Orange.data import Table, Domain, ContinuousVariable, DiscreteVariable, \
+    StringVariable
+from Orange.widgets import gui
+from Orange.widgets.settings import Setting
+from Orange.widgets.utils.owlearnerwidget import OWBaseLearner
+from Orange.widgets.utils.signals import Output
+from Orange.widgets.utils.widgetpreview import WidgetPreview
+from Orange.widgets.widget import Msg
+
+from orangeplsda import OPLSDALearner
+
+
+class OWOPLSDA(OWBaseLearner):
+    name = "OPLS-DA"
+    description = "Orthogonal Partial Least Squares Discriminant Analysis " \
+                  "with S-Plot for biomarker discovery."
+    icon = "icons/OPLSDA.svg"
+    priority = 87
+    keywords = ["orthogonal partial least squares", "discriminant analysis",
+                "classification", "OPLS-DA", "S-Plot", "biomarker"]
+
+    LEARNER = OPLSDALearner
+
+    class Outputs(OWBaseLearner.Outputs):
+        data = Output(
+            "Data with Scores",
+            Table,
+            default=True,
+        )
+        components = Output(
+            "Components",
+            Table,
+            explicit=True,
+        )
+        splot_data = Output(
+            "S-Plot Data",
+            Table,
+            explicit=True,
+        )
+        biomarkers = Output(
+            "Selected Biomarkers",
+            Table,
+            explicit=True,
+        )
+
+    n_components = Setting(1)
+    n_ortho = Setting(1)
+    scale = Setting(True)
+    max_iter = Setting(500)
+
+    want_main_area = True
+    resizing_enabled = True
+
+    def __init__(self):
+        super().__init__()
+        self.splot_p = None
+        self.splot_pcorr = None
+        self.splot_feature_names = None
+
+        # Plot area for S-Plot
+        self.plot_widget = pg.PlotWidget(
+            title="S-Plot (P(corr) vs P)"
+        )
+        self.plot_widget.setLabel("bottom", "P — Covariance Loading")
+        self.plot_widget.setLabel("left", "P(corr) — Correlation Loading")
+        self.plot_widget.showGrid(x=True, y=True, alpha=0.3)
+        self.plot_widget.setAspectLocked(False)
+        self.mainArea.layout().addWidget(self.plot_widget)
+
+        self.scatter_item = None
+        self.selected_indices = []
+
+    def add_main_layout(self):
+        box = gui.vBox(self.controlArea, "Optimization Parameters")
+        gui.spin(
+            box, self, "n_components", 1, 10, 1,
+            label="Predictive components: ",
+            alignment=Qt.AlignRight, controlWidth=80,
+            callback=self.settings_changed,
+        )
+        gui.spin(
+            box, self, "n_ortho", 0, 20, 1,
+            label="Orthogonal components: ",
+            alignment=Qt.AlignRight, controlWidth=80,
+            callback=self.settings_changed,
+        )
+        gui.spin(
+            box, self, "max_iter", 5, 1000000, 50,
+            label="Iteration limit: ",
+            alignment=Qt.AlignRight, controlWidth=100,
+            callback=self.settings_changed,
+            checkCallback=self.settings_changed,
+        )
+        gui.checkBox(
+            box, self, "scale",
+            "Scale features",
+            callback=self.settings_changed,
+        )
+
+    def create_learner(self):
+        return OPLSDALearner(
+            n_components=self.n_components,
+            n_ortho=self.n_ortho,
+            scale=self.scale,
+            max_iter=self.max_iter,
+            preprocessors=self.preprocessors,
+        )
+
+    def update_model(self):
+        super().update_model()
+        data_with_scores = None
+        components_table = None
+        splot_table = None
+        biomarkers_table = None
+
+        if self.model is not None:
+            data_with_scores = self._create_output_data()
+            components_table = self._create_output_components()
+            splot_table = self._create_splot_table()
+            biomarkers_table = self._compute_biomarkers()
+            self._draw_splot()
+
+        self.Outputs.data.send(data_with_scores)
+        self.Outputs.components.send(components_table)
+        self.Outputs.splot_data.send(splot_table)
+        self.Outputs.biomarkers.send(biomarkers_table)
+
+    def _create_output_data(self):
+        """Augment data with OPLS scores and predictions."""
+        data = self.data
+        model = self.model
+        model_data = model.data_to_model_domain(data)
+        Xt = model_data.X
+
+        # Deflate and get scores
+        X_scaled = (Xt - model.x_mean) / model.x_std \
+            if model.scaled else Xt - model.x_mean
+        Xd = X_scaled.copy()
+        for i in range(model.n_ortho):
+            t_o = Xd @ model.w_ortho[i].ravel()
+            Xd -= np.outer(t_o, model.p_ortho[i].ravel())
+        t_pred = Xd @ model.w_pred.ravel()
+
+        # Orthogonal scores
+        ortho_names = []
+        for i in range(model.n_ortho):
+            ortho_names.append(f"t_o{i + 1}")
+
+        # Predicted class + probabilities
+        y_raw = model._predict_raw(Xt)
+        if y_raw.ndim == 1:
+            y_raw = y_raw.reshape(-1, 1)
+        pred_class = np.argmax(y_raw, axis=1)
+        y_max = y_raw.max(axis=1, keepdims=True)
+        exp_s = np.exp(y_raw - y_max)
+        probs = exp_s / exp_s.sum(axis=1, keepdims=True)
+
+        class_var = data.domain.class_var
+        score_names = ["t_pred"] + ortho_names
+        prob_names = [
+            f"p({class_var.name}={v})" for v in class_var.values
+        ]
+
+        new_attrs = data.domain.attributes \
+            + tuple(ContinuousVariable(n) for n in score_names)
+        new_metas = data.domain.metas \
+            + (DiscreteVariable("Predicted", values=class_var.values),) \
+            + tuple(ContinuousVariable(n) for n in prob_names)
+
+        new_domain = Domain(new_attrs, data.domain.class_vars, new_metas)
+        aug_data = data.transform(new_domain)
+
+        n_orig_attrs = len(data.domain.attributes)
+        n_new_attr = len(score_names)
+        with aug_data.unlocked(aug_data.X):
+            aug_data.X[:, n_orig_attrs] = t_pred
+            for i in range(model.n_ortho):
+                t_o_idx = n_orig_attrs + 1 + i
+                if t_o_idx < aug_data.X.shape[1]:
+                    Xd2 = X_scaled.copy()
+                    for j in range(i + 1):
+                        tt = Xd2 @ model.w_ortho[j].ravel()
+                        Xd2 -= np.outer(tt, model.p_ortho[j].ravel())
+                    aug_data.X[:, t_o_idx] = Xd2 @ model.w_ortho[i].ravel()
+
+        with aug_data.unlocked(aug_data.metas):
+            aug_data.metas[:, -len(prob_names) - 1] = pred_class.astype(float)
+            aug_data.metas[:, -len(prob_names):] = probs
+
+        aug_data.name = f"{data.name} - OPLS-DA scores"
+        return aug_data
+
+    def _create_output_components(self):
+        """Return a Table of predictive and orthogonal loadings."""
+        model = self.model
+        n_total = 1 + model.n_ortho
+        comp_names = ["Predictive"] + [f"Ortho {i + 1}" for i in range(model.n_ortho)]
+
+        attr_names = [a.name for a in model.domain.attributes]
+        dom = Domain(
+            [ContinuousVariable(n) for n in comp_names],
+            metas=[StringVariable("Variable")],
+        )
+        X = np.zeros((len(attr_names), n_total))
+        X[:, 0] = model.p_pred.ravel()
+        for i in range(model.n_ortho):
+            X[:, 1 + i] = model.p_ortho[i].ravel()
+        metas = np.array(attr_names, dtype=object).reshape(-1, 1)
+        comp = Table.from_numpy(dom, X=X, metas=metas)
+        comp.name = "OPLS-DA components"
+        return comp
+
+    def _create_splot_table(self):
+        """Return S-Plot coordinates as a Table."""
+        model = self.model
+        data = self.data
+        model_data = model.data_to_model_domain(data)
+        Xt = model_data.X
+
+        p_vals, pcorr_vals, t_pred = model.plot_data(Xt)
+        self.splot_p = p_vals
+        self.splot_pcorr = pcorr_vals
+        self.splot_feature_names = [a.name for a in model.domain.attributes]
+
+        dom = Domain(
+            [ContinuousVariable("p"),
+             ContinuousVariable("p(corr)")],
+            metas=[StringVariable("Variable")],
+        )
+        X = np.column_stack((p_vals, pcorr_vals))
+        metas = np.array(self.splot_feature_names, dtype=object).reshape(-1, 1)
+        st = Table.from_numpy(dom, X=X, metas=metas)
+        st.name = "S-Plot data"
+        return st
+
+    def _compute_biomarkers(self):
+        """Identify top biomarkers by |p| > threshold."""
+        if self.splot_p is None or self.splot_feature_names is None:
+            return None
+
+        # Biomarkers = variables with |p(corr)| > 0.5 (or high |p|)
+        p_abs = np.abs(self.splot_p)
+        pcorr_abs = np.abs(self.splot_pcorr)
+        score = p_abs * pcorr_abs  # combined importance
+
+        idx = np.argsort(score)[::-1]
+        dom = Domain(
+            [ContinuousVariable("p"),
+             ContinuousVariable("p(corr)"),
+             ContinuousVariable("Importance")],
+            metas=[StringVariable("Variable")],
+        )
+        X = np.column_stack((
+            self.splot_p[idx], self.splot_pcorr[idx], score[idx],
+        ))
+        metas = np.array(
+            [self.splot_feature_names[i] for i in idx],
+            dtype=object,
+        ).reshape(-1, 1)
+        bt = Table.from_numpy(dom, X=X, metas=metas)
+        bt.name = "Biomarkers (S-Plot)"
+        return bt
+
+    def _draw_splot(self):
+        """Draw the S-Plot in the widget."""
+        self.plot_widget.clear()
+        if self.splot_p is None or self.splot_pcorr is None:
+            return
+
+        self.scatter_item = pg.ScatterPlotItem(
+            x=self.splot_p,
+            y=self.splot_pcorr,
+            pen=pg.mkPen(0.3, width=0.5),
+            brush=pg.mkBrush(60, 120, 200, 180),
+            size=6,
+        )
+        self.plot_widget.addItem(self.scatter_item)
+
+        # Horizontal/vertical lines at 0
+        self.plot_widget.addLine(x=0, pen=QColor(180, 180, 180, 120))
+        self.plot_widget.addLine(y=0, pen=QColor(180, 180, 180, 120))
+
+        # Label top/bottom biomarkers
+        scores = np.abs(self.splot_p) * np.abs(self.splot_pcorr)
+        top3 = np.argsort(scores)[-3:]
+        label_pen = pg.mkPen(color=(40, 40, 40))
+        for i in top3:
+            txt = pg.TextItem(
+                text=self.splot_feature_names[i],
+                anchor=(0.5, 1.5),
+                color=(40, 40, 40),
+            )
+            txt.setPos(self.splot_p[i], self.splot_pcorr[i])
+            self.plot_widget.addItem(txt)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    WidgetPreview(OWOPLSDA).run(Table("zoo"))

orangeplsda/widgets/owplsda.py

@@ -0,0 +1,192 @@
+"""
+OWPLSDA widget — Partial Least Squares Discriminant Analysis.
+
+Provides a PLS-DA classification widget for Orange3 that works with
+categorical (discrete) class variables, unlike the existing PLS-R widget
+which only works with numeric targets.
+"""
+
+import numpy as np
+from AnyQt.QtCore import Qt
+
+from Orange.data import Table, Domain, ContinuousVariable, DiscreteVariable, \
+    StringVariable
+from Orange.widgets import gui
+from Orange.widgets.settings import Setting
+from Orange.widgets.utils.owlearnerwidget import OWBaseLearner
+from Orange.widgets.utils.signals import Output
+from Orange.widgets.utils.widgetpreview import WidgetPreview
+from Orange.widgets.widget import Msg
+
+from orangeplsda import PLSDALearner
+
+
+class OWPLSDA(OWBaseLearner):
+    name = "PLS-DA"
+    description = "Partial Least Squares Discriminant Analysis " \
+                  "for classification with categorical targets."
+    icon = "icons/PLSDA.svg"
+    priority = 86
+    keywords = ["partial least squares", "discriminant analysis",
+                "classification", "PLS-DA"]
+
+    LEARNER = PLSDALearner
+
+    class Outputs(OWBaseLearner.Outputs):
+        data = Output(
+            "Data with Scores",
+            Table,
+            default=True,
+        )
+        components = Output(
+            "Components",
+            Table,
+            explicit=True,
+        )
+
+    class Warning(OWBaseLearner.Warning):
+        few_features = Msg(
+            "Number of components reduced to match data dimensions."
+        )
+
+    n_components = Setting(2)
+    max_iter = Setting(500)
+    scale = Setting(True)
+
+    def add_main_layout(self):
+        """Build the widget's control area UI."""
+        optimization_box = gui.vBox(
+            self.controlArea, "Optimization Parameters"
+        )
+        gui.spin(
+            optimization_box, self, "n_components", 1, 50, 1,
+            label="Components: ",
+            alignment=Qt.AlignRight, controlWidth=100,
+            callback=self.settings_changed,
+        )
+        gui.spin(
+            optimization_box, self, "max_iter", 5, 1000000, 50,
+            label="Iteration limit: ",
+            alignment=Qt.AlignRight, controlWidth=100,
+            callback=self.settings_changed,
+            checkCallback=self.settings_changed,
+        )
+        gui.checkBox(
+            optimization_box, self, "scale",
+            "Scale features",
+            callback=self.settings_changed,
+        )
+
+    def create_learner(self):
+        return PLSDALearner(
+            n_components=self.n_components,
+            scale=self.scale,
+            max_iter=self.max_iter,
+            preprocessors=self.preprocessors,
+        )
+
+    def update_model(self):
+        """Called after the model is (re-)trained. Sends outputs."""
+        super().update_model()
+
+        data_with_scores = None
+        components_table = None
+
+        if self.model is not None:
+            data_with_scores = self._create_output_data()
+            components_table = self._create_output_components()
+
+        self.Outputs.data.send(data_with_scores)
+        self.Outputs.components.send(components_table)
+
+    def _create_output_data(self):
+        """Create a table with PLS scores, predicted classes, and probabilities.
+
+        Augments the input data with:
+        - PLS X-scores (T1, T2, ...)
+        - PLS Y-scores (U1, U2, ...)
+        - Predicted class
+        - Class probabilities (one column per class value)
+        """
+        data = self.data
+        model = self.model
+
+        # Transform data through the model's domain (handles preprocessing
+        # like one-hot encoding of categorical features, scaling, etc.)
+        model_data = model.data_to_model_domain(data)
+
+        # Project into PLS space via the model
+        n_comp = model.skl_model.n_components
+        x_scores = model.skl_model.transform(model_data.X)
+
+        # Predict class and get probabilities
+        raw_scores = model.skl_model.predict(model_data.X)
+        if raw_scores.ndim == 1:
+            raw_scores = raw_scores.reshape(-1, 1)
+        pred_class = np.argmax(raw_scores, axis=1)
+
+        # Softmax probabilities
+        exp_s = np.exp(raw_scores - raw_scores.max(axis=1, keepdims=True))
+        probs = exp_s / exp_s.sum(axis=1, keepdims=True)
+
+        # Build augmented domain
+        class_var = data.domain.class_var
+        score_names_x = [f"T{i + 1}" for i in range(n_comp)]
+        prob_names = [
+            f"p({class_var.name}={v})" for v in class_var.values
+        ]
+
+        # Add PLS scores as attributes
+        new_attrs = data.domain.attributes \
+            + tuple(ContinuousVariable(n) for n in score_names_x)
+
+        # Add predicted class and probabilities as metas
+        new_metas = data.domain.metas \
+            + (DiscreteVariable("Predicted", values=class_var.values),) \
+            + tuple(ContinuousVariable(n) for n in prob_names)
+
+        new_domain = Domain(new_attrs, data.domain.class_vars, new_metas)
+
+        # Build augmented data by transforming original data to new domain,
+        # then filling in the new columns
+        aug_data = data.transform(new_domain)
+
+        # Fill in PLS scores (first new attributes)
+        n_orig_attrs = len(data.domain.attributes)
+        with aug_data.unlocked(aug_data.X):
+            aug_data.X[:, n_orig_attrs:n_orig_attrs + n_comp] = x_scores
+
+        # Fill in predicted class and probabilities (last metas)
+        with aug_data.unlocked(aug_data.metas):
+            aug_data.metas[:, -len(prob_names) - 1] = pred_class.astype(float)
+            aug_data.metas[:, -len(prob_names):] = probs
+
+        aug_data.name = f"{data.name} - PLS-DA scores"
+        return aug_data
+
+    def _create_output_components(self):
+        """Build a components (loadings) table showing X and Y loadings."""
+        model = self.model
+        skl = model.skl_model
+
+        n_components = skl.x_loadings_.shape[1]
+
+        # X loadings — use model domain attributes which match preprocessed features
+        attr_names = [a.name for a in model.domain.attributes]
+        comp_names = [f"Comp {i + 1}" for i in range(n_components)]
+
+        dom = Domain(
+            [ContinuousVariable(n) for n in comp_names],
+            metas=[StringVariable("Variable")],
+        )
+
+        X = skl.x_loadings_  # n_features x n_comp
+        metas = np.array(attr_names, dtype=object).reshape(-1, 1)
+
+        components = Table.from_numpy(dom, X=X, metas=metas)
+        components.name = "PLS-DA components (X loadings)"
+        return components
+
+
+if __name__ == "__main__":  # pragma: no cover
+    WidgetPreview(OWPLSDA).run(Table("zoo"))

orangeplsda-0.1.0.dist-info/METADATA

@@ -0,0 +1,304 @@
+Metadata-Version: 2.4
+Name: orangeplsda
+Version: 0.1.0
+Summary: PLS-DA & OPLS-DA with S-Plot — classification, biomarker discovery, and orthogonal signal correction for Orange3
+Author: Philipp Weller
+Author-email: philipp.weller@googlemail.com
+Project-URL: Source, https://github.com/philippweller/WellerLab/tree/main/orange-plsda-addon
+Project-URL: Bug Tracker, https://github.com/philippweller/WellerLab/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Description-Content-Type: text/markdown
+Requires-Dist: Orange3>=3.40.0
+Requires-Dist: numpy
+Requires-Dist: scikit-learn
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: summary
+
+# orange-plsda-addon
+
+PLS-DA & OPLS-DA für **Orange3** — Leistungsstarke Klassifikations-Widgets für
+die multivariate Analyse (Chemometrie, Biomarker-Findung).
+
+- **PLS-DA** (Partial Least Squares Discriminant Analysis) — Klassifikation
+  mittels `PLSRegression` mit One-hot-kodiertem Ziel
+- **OPLS-DA** (Orthogonal PLS-DA, Trygg & Wold 2002) — trennt prädiktive von
+  orthogonaler (klassen-unabhängiger) Variation
+
+Beide Widgets erscheinen in Orange unter der Kategorie **PLS-DA**, direkt
+neben dem eingebauten PLS-R.
+
+---
+
+## ⚡ Automatischer Installer (empfohlen)
+
+Dieses Paket ist Teil des **WellerLab**-Monorepos
+(`github.com/philippweller/WellerLab`). Der gemeinsame Installer
+`orange-install.py` (auf Repo-Ebene) findet **Oranges eigenes Python**
+automatisch und installiert das Paket korrekt (macOS / Windows / Linux). Kein
+manuelles Pfad-Raten mehr:
+
+```bash
+# PLS-DA installieren:
+python orange-install.py plsda
+
+# NMR-Add-on installieren:
+python orange-install.py nmr
+
+# nur zeigen, welches Python erkannt wurde:
+python orange-install.py --show
+
+# bestehende Installation prüfen:
+python orange-install.py --check plsda
+```
+
+Läuft mit **jedem** Python (nur Standardbibliothek). Klappt die
+Auto-Erkennung ausnahmsweise nicht:
+
+```bash
+python orange-install.py --python /pfad/zum/orange/python
+```
+
+> ▶️ **Direkt ausführen ohne Clone** (das Add-on wird trotzdem via GitHub
+> installiert):
+> ```bash
+> curl -fsSL https://raw.githubusercontent.com/philippweller/WellerLab/main/orange-install.py -o orange-install.py && python3 orange-install.py plsda
+> ```
+
+Das Tool bedient auch den **Windows-`--no-user`-Fall** automatisch, sodass
+das Add-on in Oranges eigene `site-packages` landet statt in die unsichtbare
+User-Site.
+
+---
+
+## 📋 Voraussetzungen
+
+| Voraussetzung | Hinweis |
+|---|---|
+| Orange3 ≥ 3.40 installiert | Unter **Hilfe → Über** die Version prüfen |
+| Internet-Zugriff auf GitHub | zum Herunterladen des Repos |
+
+> ⚠️ **Wichtig:** Es muss immer **Oranges eigenes Python** verwendet werden,
+> nicht `/usr/bin/python3`! Sonst wird das Add-on in der falschen Python-Umgebung
+> installiert und Orange findet es nicht.
+
+---
+
+## 🔍 Oranges eingebettetes Python finden (wichtig!)
+
+Der Pfad zu Oranges Python **hängt von der Orange-Version ab**. Je nachdem
+ob Orange mit Python 3.11 oder 3.12 gebaut wurde, heißt das Binary
+`python3`, `python3.11` oder `python3.12`.
+
+**Sichere Methode — das echte Python-Binary lokalisieren:**
+
+```bash
+ls /Applications/Orange.app/Contents/Frameworks/Python.framework/Versions/
+# zeigt z.B.:  3.12   und   Current -> 3.12
+
+# Dann das echte Binary finden:
+find /Applications/Orange.app -name "python3*" -type f 2>/dev/null | grep -i bin
+```
+
+Typische gültige Pfade (je nach Version):
+
+| Orange mit | Python-Binary |
+|---|---|
+| Python 3.11 | `.../Versions/Current/bin/python3` |
+| Python 3.11 (nur versioniert) | `.../Versions/Current/bin/python3.11` |
+| Python 3.12 | `.../Versions/Current/bin/python3.12` |
+| Intel-Mac mit 3.12 | `.../Versions/Current/bin/python3.12-intel64` |
+
+> `Current` ist ein Symlink zur installierten Version (`Current -> 3.12`),
+> funktioniert also in allen Fällen. Ersetze in den Befehlen unten
+> `ORANGEPY` durch **den** gefundenen Pfad.
+
+---
+
+## 🚀 Installation (Schritt für Schritt)
+
+### macOS (Orange.app als `.app` installiert)
+
+**Schritt 1 — Oranges eingebettetes Python prüfen:**
+
+Öffne einen Terminal und führe aus (nutze den Pfad aus dem Abschnitt
+[Oranges eingebettetes Python finden](#-oranges-eingebettetes-python-finden-wichtig);
+je nach Orange-Version heißt das Binary `python3`, `python3.11` oder `python3.12`):
+
+```bash
+/Applications/Orange.app/Contents/Frameworks/Python.framework/Versions/Current/bin/python3.12 --version
+```
+
+Es sollte eine Python-3.x-Version ausgeben. Notiere dir diesen Pfad — er wird
+in den nächsten Schritten gebraucht (im Folgenden abgekürzt als `ORANGEPY`).
+
+**Schritt 2 — Add-on von GitHub installieren:**
+
+```bash
+ORANGEPY=/Applications/Orange.app/Contents/Frameworks/Python.framework/Versions/Current/bin/python3.12
+$ORANGEPY -m pip install git+https://github.com/philippweller/WellerLab.git@main#subdirectory=orange-plsda-addon
+```
+
+**Schritt 3 — Installation prüfen (optional, empfohlen):**
+
+```bash
+$ORANGEPY -c "from orangeplsda import PLSDALearner; print('OK')"
+```
+
+Wenn `OK` erscheint, ist das Paket korrekt installiert.
+
+**Schritt 4 — In Orange öffnen:**
+
+Orange starten. Die Widgets **PLS-DA** und **OPLS-DA** erscheinen in der
+Widget-Leiste unter **PLS-DA**. Du musst Orange nicht neu starten — es reicht,
+das Canvas-Fenster erneut zu öffnen.
+
+---
+
+### Windows (Orange über den "Orange Command Prompt")
+
+**Schritt 1 — Orange Command Prompt öffnen:**
+
+Startmenü → *Orange* → *Orange Command Prompt* (bzw. *Qt Console*).
+
+**Schritt 2 — Installieren:**
+
+```cmd
+python -m pip install git+https://github.com/philippweller/WellerLab.git@main#subdirectory=orange-plsda-addon
+```
+
+**Schritt 3 — Prüfen:**
+
+```cmd
+python -c "from orangeplsda import PLSDALearner; print('OK')"
+```
+
+**Schritt 4 — Orange öffnen** und unter **PLS-DA** nachschauen.
+
+---
+
+### Linux / Conda / Venv
+
+**Schritt 1 — Umgebung aktivieren:**
+
+```bash
+conda activate orange    # oder: source .venv/bin/activate
+```
+
+**Schritt 2 — Installieren:**
+
+```bash
+pip install git+https://github.com/philippweller/WellerLab.git@main#subdirectory=orange-plsda-addon
+```
+
+**Schritt 3 — Prüfen:**
+
+```bash
+python -c "from orangeplsda import PLSDALearner; print('OK')"
+```
+
+**Schritt 4 — Orange starten** und das Widget suchen.
+
+---
+
+## 🔄 Updates einspielen (bei neuen Versionen)
+
+Auf **jedem** Rechner, auf dem das Add-on installiert ist:
+
+**Schritt 1 — aktuelle Version installieren (Überschreibt die alte):**
+
+```bash
+# macOS
+$ORANGEPY -m pip install --upgrade --force-reinstall git+https://github.com/philippweller/WellerLab.git@main#subdirectory=orange-plsda-addon
+```
+
+```bash
+# Windows / Linux / Conda
+python -m pip install --upgrade --force-reinstall git+https://github.com/philippweller/WellerLab.git@main#subdirectory=orange-plsda-addon
+```
+
+**Schritt 2 — Orange neu starten**, damit die neuen Widget-Versionen geladen werden.
+
+> Hinweis: `--force-reinstall` wird empfohlen, da Orange die Widgets beim
+> Canvas-Öffnen zwischenspeichert.
+
+---
+
+## 🗑️ Deinstallation
+
+```bash
+# macOS
+$ORANGEPY -m pip uninstall orangeplsda -y
+```
+
+```bash
+# Windows / Linux / Conda
+python -m pip uninstall orangeplsda -y
+```
+
+Danach Orange neu starten — die Widgets sind verschwunden.
+
+---
+
+## 🧪 Kurzer Funktionstest (Entwickler)
+
+Mit Oranges Python auf einem der mitgelieferten Datensätze:
+
+```bash
+python -c "
+from Orange.data import Table
+from Orange.base import Model
+from orangeplsda import PLSDALearner
+from orangeplsda.oplsda_learner import OPLSDALearner
+for L, kw in [(PLSDALearner, dict(n_components=2)),
+              (OPLSDALearner, dict(n_components=1, n_ortho=1))]:
+    t = Table('iris'); m = L(**kw)(t)
+    p, pr = m(t, ret=Model.ValueProbs)
+    print(L.__name__, round(float((p == t.Y.flatten()).mean()), 3), pr.shape)
+"
+```
+
+Erwartete Ausgabe (beispielhaft, kann leicht abweichen):
+
+```
+PLSDALearner 0.813 (150, 3)
+OPLSDALearner 0.8 (150, 3)
+```
+
+---
+
+## 🛠️ Fehlerbehebung
+
+| Problem | Lösung |
+|---|---|
+| "`python3` ist nicht vorhanden" / Datei nicht gefunden | Das Binary heißt je nach Orange-Version `python3`, `python3.11` oder `python3.12` (z.B. Orange mit Python 3.12). Mit `find /Applications/Orange.app -name "python3*" -type f` den echten Namen ermitteln. |
+| `from orangeplsda import ...` schlägt fehl | Du hast `/usr/bin/python3` statt Oranges Python benutzt. Siehe Schritt 1 oben. |
+| Widget erscheint nicht in Orange | Gelöschte `*.egg-info`/`__pycache__` prüfen; Orange vollständig neu starten; `pip show orangeplsda` ausführen. |
+| `Host key verification failed` beim pip install | Läuft nur bei einem gepushten SSH-Workflow, nicht bei `git+https://`. Nutze die https-URL. |
+| alte Version bleibt | `pip install --force-reinstall` verwenden (siehe Updates). |
+
+---
+
+## 📦 Entwicklung / Repo lokal ausprobieren
+
+```bash
+git clone git@github.com:philippweller/orange-plsda-addon.git
+cd orange-plsda-addon
+# Editable-Install mit Oranges Python:
+$ORANGEPY -m pip install -e .
+```
+
+---
+
+## 📄 Lizenz
+
+MIT © Philipp Weller

orangeplsda-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+orangeplsda/__init__.py,sha256=zgCCNLE81dw33rlhy2REUHvXzt33In_W1muf9V10xl8,327
+orangeplsda/oplsda_learner.py,sha256=Y90BsZON1tlt8TTJRyvd_FJtzW-L2am6Zjt0ctkp5eg,11149
+orangeplsda/plsda_learner.py,sha256=fZbhsutGCOTmXwE23bPGEt6SrOZTTHZU-v89OGZ1Crg,4096
+orangeplsda/widgets/__init__.py,sha256=WhoYDwW6n8iT7ggBqJXAsMxOVwFIL6V_Zn-uQzwS6BU,139
+orangeplsda/widgets/owoplsda.py,sha256=VbXluAZGoVGSLofnIILU4bSv7yS05-_et6mXCX6MM0M,10839
+orangeplsda/widgets/owplsda.py,sha256=Eem7r5drfPr97AMynpeUdamYqrDo3Cxl3hVOhLtkDCI,6603
+orangeplsda/widgets/icons/OPLSDA.svg,sha256=uWyf09OgRhD0rfE5lCz1HpwYviwpVAJLsvfBsaOeIbQ,770
+orangeplsda/widgets/icons/PLSDA.svg,sha256=NolAdlEDpdn2OaiWs-x25yPFYBtMcxuN5nOtbptFFVM,631
+orangeplsda-0.1.0.dist-info/METADATA,sha256=flhS8qHgOlFkno5AXpNnqty60tT1XthAJR6imAQV37k,9314
+orangeplsda-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+orangeplsda-0.1.0.dist-info/entry_points.txt,sha256=Xm1rYknZVE8c5DZ_4R8-WuTx5Jv4PcdF1QsfHD_M4ik,46
+orangeplsda-0.1.0.dist-info/top_level.txt,sha256=W6UoRienZbpiQHCvCLtWJB2ccLVgyHBYOA4WB6OHDBM,12
+orangeplsda-0.1.0.dist-info/RECORD,,

orangeplsda-0.1.0.dist-info/WHEEL

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

orangeplsda-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[orange.widgets]
+PLS-DA = orangeplsda.widgets

orangeplsda-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+orangeplsda