validmind 2.13.11__tar.gz → 2.13.13__tar.gz

{validmind-2.13.11 → validmind-2.13.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: validmind
-Version: 2.13.11
+Version: 2.13.13
 Summary: ValidMind Library
 Author-email: Andres Rodriguez <andres@validmind.ai>, Juan Martinez <juan@validmind.ai>, Anil Sorathiya <anil@validmind.ai>, Luis Pallares <luis@validmind.ai>, John Walz <john@validmind.ai>
 License:                          DUAL LICENSE NOTICE

{validmind-2.13.11 → validmind-2.13.13}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "validmind"
-version = "2.13.11"
+version = "2.13.13"
 description = "ValidMind Library"
 readme = "README.pypi.md"
 requires-python = ">=3.9,<3.15"

validmind-2.13.13/validmind/__version__.py

@@ -0,0 +1 @@
+__version__ = "2.13.13"

{validmind-2.13.11 → validmind-2.13.13}/validmind/tests/data_validation/LaggedCorrelationHeatmap.py

@@ -6,7 +6,6 @@ from typing import Tuple
 
 import numpy as np
 import pandas as pd
-import plotly.figure_factory as ff
 import plotly.graph_objects as go
 
 from validmind import RawData, tags, tasks
@@ -86,13 +85,15 @@ def LaggedCorrelationHeatmap(
         index=dataset.feature_columns,
     )
 
-    fig = ff.create_annotated_heatmap(
-        z=correlation_df.values,
-        x=list(correlation_df.columns),
-        y=list(correlation_df.index),
-        colorscale=COOLWARM,
-        annotation_text=correlation_df.round(2).values,
-        showscale=True,
+    fig = go.Figure(
+        go.Heatmap(
+            z=correlation_df.values,
+            x=list(correlation_df.columns),
+            y=list(correlation_df.index),
+            colorscale=COOLWARM,
+            showscale=True,
+            texttemplate="%{z:.2f}",
+        )
     )
     fig.update_layout(
         title={
@@ -103,7 +104,8 @@ def LaggedCorrelationHeatmap(
             "yanchor": "top",
         },
         font=dict(size=14),
-        xaxis_title="Lags",
+        xaxis=dict(title="Lags", side="top", dtick=1),
+        yaxis=dict(dtick=1),
     )
 
     return fig, RawData(correlation_matrix=correlation_df, dataset=dataset.input_id)

{validmind-2.13.11 → validmind-2.13.13}/validmind/tests/data_validation/TimeSeriesMissingValues.py

@@ -6,7 +6,6 @@ from typing import Any, Dict, List, Tuple
 
 import pandas as pd
 import plotly.express as px
-import plotly.figure_factory as ff
 import plotly.graph_objects as go
 
 from validmind import RawData, tags, tasks
@@ -94,16 +93,23 @@ def TimeSeriesMissingValues(
     z = missing_mask.T.astype(int).values
     x = missing_mask.index.tolist()
     y = missing_mask.columns.tolist()
-    heatmap = ff.create_annotated_heatmap(
-        z=z,
-        x=x,
-        y=y,
-        colorscale="Reds",
-        showscale=False,
+    heatmap = go.Figure(
+        go.Heatmap(
+            z=z,
+            x=x,
+            y=y,
+            colorscale="Reds",
+            showscale=False,
+            texttemplate="%{z}",
+        )
     )
 
     # Update the layout after creation
-    heatmap.update_layout(title="Missing Values Heatmap")
+    heatmap.update_layout(
+        title="Missing Values Heatmap",
+        xaxis=dict(side="top", dtick=1),
+        yaxis=dict(dtick=1),
+    )
 
     return (
         [

{validmind-2.13.11 → validmind-2.13.13}/validmind/tests/model_validation/RegressionResidualsPlot.py

@@ -5,12 +5,29 @@
 from typing import Tuple
 
 import numpy as np
-import plotly.figure_factory as ff
 import plotly.graph_objects as go
 
 from validmind import RawData, tags, tasks
+from validmind.errors import MissingDependencyError
 from validmind.vm_models import VMDataset, VMModel
 
+# The first colour in Plotly's default distplot palette, kept so the ported figure
+# matches what `ff.create_distplot` produced.
+KDE_COLOR = "rgb(31, 119, 180)"
+
+try:
+    from scipy.stats import gaussian_kde
+except ImportError as e:
+    if "scipy" in str(e):
+        raise MissingDependencyError(
+            "Missing required package `scipy` for RegressionResidualsPlot. "
+            "Please run `pip install validmind[stats]` to use statistical tests",
+            required_dependencies=["scipy"],
+            extra="stats",
+        ) from e
+
+    raise e
+
 
 @tags("model_performance", "visualization")
 @tasks("regression")
@@ -65,12 +82,30 @@ def RegressionResidualsPlot(
 
     # Residuals plot
     residuals = y_true.flatten() - y_pred.flatten()
-    fig = ff.create_distplot(
-        hist_data=[residuals],
-        group_labels=["Residuals"],
-        bin_size=[bin_size],
-        show_hist=True,
-        show_rug=False,
+    # A 500-point KDE across the data range, which is what `ff.create_distplot`
+    # computed internally with scipy before Plotly 7 removed it.
+    curve_x = np.linspace(residuals.min(), residuals.max(), 500, endpoint=False)
+    curve_y = gaussian_kde(residuals)(curve_x)
+    fig = go.Figure(
+        data=[
+            go.Histogram(
+                x=residuals,
+                histnorm="probability density",
+                autobinx=False,
+                xbins=dict(start=residuals.min(), end=residuals.max(), size=bin_size),
+                name="Residuals",
+                marker=dict(color=KDE_COLOR),
+                opacity=0.7,
+            ),
+            go.Scatter(
+                x=curve_x,
+                y=curve_y,
+                mode="lines",
+                name="Residuals",
+                showlegend=False,
+                marker=dict(color=KDE_COLOR),
+            ),
+        ]
     )
     fig.update_layout(
         title="Distribution of Residuals",

{validmind-2.13.11 → validmind-2.13.13}/validmind/tests/model_validation/sklearn/ConfusionMatrix.py

@@ -6,7 +6,6 @@
 from typing import Tuple
 
 import numpy as np
-import plotly.figure_factory as ff
 import plotly.graph_objects as go
 from sklearn.metrics import confusion_matrix
 
@@ -42,9 +41,9 @@ def ConfusionMatrix(
     The mechanism used involves taking the predicted results (`y_test_predict`) from the classification model and
     comparing them against the actual values (`y_test_true`). A confusion matrix is built using the unique labels
     extracted from `y_test_true`, employing scikit-learn's metrics. The matrix is then visually rendered with the help
-    of Plotly's `create_annotated_heatmap` function. A heatmap is created which provides a two-dimensional graphical
-    representation of the model's performance, showcasing distributions of True Positives (TP), True Negatives (TN),
-    False Positives (FP), and False Negatives (FN).
+    of a Plotly heatmap. A heatmap is created which provides a two-dimensional graphical representation of the
+    model's performance, showcasing distributions of True Positives (TP), True Negatives (TN), False Positives (FP),
+    and False Negatives (FN).
 
     ### Signs of High Risk
 
@@ -110,21 +109,32 @@ def ConfusionMatrix(
             ],
         ]
 
-    fig = ff.create_annotated_heatmap(
-        z=cm,
-        colorscale="Blues",
-        x=labels,
-        y=labels,
-        annotation_text=text,
+    if text is None:
+        text = cm.astype(str)
+
+    fig = go.Figure(
+        go.Heatmap(
+            z=cm,
+            x=labels,
+            y=labels,
+            colorscale="Blues",
+            showscale=False,
+            text=text,
+            texttemplate="%{text}",
+            # Heatmap text auto-shrinks to fit the cell; pin it to the layout font
+            # size so the cells read the same as the old annotation-based figure.
+            textfont=dict(size=12),
+            hovertemplate=(
+                "True Label:%{y}<br>Predicted Label:%{x}<br>Count:%{z}<extra></extra>"
+            ),
+        )
     )
 
-    fig["data"][0][
-        "hovertemplate"
-    ] = "True Label:%{y}<br>Predicted Label:%{x}<br>Count:%{z}<extra></extra>"
-
     fig.update_layout(
-        xaxis=dict(title="Predicted label"),
-        yaxis=dict(title="True label"),
+        # `side="top"` and `dtick=1` keep the axis placement and per-class ticks that
+        # `ff.create_annotated_heatmap` used to apply for us.
+        xaxis=dict(title="Predicted label", side="top", dtick=1),
+        yaxis=dict(title="True label", dtick=1),
         autosize=False,
         width=600,
         height=600,

{validmind-2.13.11 → validmind-2.13.13}/validmind/tests/ongoing_monitoring/TargetPredictionDistributionPlot.py

@@ -4,8 +4,8 @@
 
 from typing import Dict, List, Tuple
 
+import numpy as np
 import pandas as pd
-import plotly.figure_factory as ff
 import plotly.graph_objects as go
 
 from validmind import RawData, tags, tasks
@@ -13,7 +13,7 @@ from validmind.errors import MissingDependencyError
 from validmind.vm_models import VMDataset, VMModel
 
 try:
-    from scipy.stats import kurtosis, skew
+    from scipy.stats import gaussian_kde, kurtosis, skew
 except ImportError as e:
     if "scipy" in str(e):
         raise MissingDependencyError(
@@ -26,6 +26,17 @@ except ImportError as e:
     raise e
 
 
+def _kde_curve(values):
+    """A 500-point KDE across the data range.
+
+    This is what `ff.create_distplot(..., show_hist=False)` computed internally
+    before Plotly 7 removed the Figure Factory functions.
+    """
+    x = np.linspace(values.min(), values.max(), 500, endpoint=False)
+
+    return x, gaussian_kde(values)(x)
+
+
 @tags("visualization")
 @tasks("monitoring")
 def TargetPredictionDistributionPlot(
@@ -110,18 +121,8 @@ def TargetPredictionDistributionPlot(
     moments = moments.set_index("Statistic", drop=False)
 
     # Create KDE for both distributions
-    ref_kde = ff.create_distplot(
-        [pred_ref["Reference Prediction"].values],
-        ["Reference"],
-        show_hist=False,
-        show_rug=False,
-    )
-    monitor_kde = ff.create_distplot(
-        [pred_monitor["Monitoring Prediction"].values],
-        ["Monitoring"],
-        show_hist=False,
-        show_rug=False,
-    )
+    ref_x, ref_y = _kde_curve(pred_ref["Reference Prediction"].values)
+    monitor_x, monitor_y = _kde_curve(pred_monitor["Monitoring Prediction"].values)
 
     # Create new figure
     fig = go.Figure()
@@ -129,8 +130,8 @@ def TargetPredictionDistributionPlot(
     # Add reference distribution
     fig.add_trace(
         go.Scatter(
-            x=ref_kde.data[0].x,
-            y=ref_kde.data[0].y,
+            x=ref_x,
+            y=ref_y,
             fill="tozeroy",
             name="Reference Prediction",
             line=dict(color="blue", width=2),
@@ -141,8 +142,8 @@ def TargetPredictionDistributionPlot(
     # Add monitoring distribution
     fig.add_trace(
         go.Scatter(
-            x=monitor_kde.data[0].x,
-            y=monitor_kde.data[0].y,
+            x=monitor_x,
+            y=monitor_y,
             fill="tozeroy",
             name="Monitor Prediction",
             line=dict(color="red", width=2),

{validmind-2.13.11 → validmind-2.13.13}/validmind/unit_metrics/regression/GiniCoefficient.py

@@ -7,6 +7,10 @@ import numpy as np
 from validmind import tags, tasks
 from validmind.vm_models import VMDataset, VMModel
 
+# NumPy 2 removed `np.trapz` in favour of `np.trapezoid`; the library supports both
+# (numpy<2 below Python 3.14, numpy>=2.3 from 3.14 on).
+_trapezoid = getattr(np, "trapezoid", None) or np.trapz
+
 
 @tags("regression")
 @tasks("regression")
@@ -29,7 +33,7 @@ def GiniCoefficient(dataset: VMDataset, model: VMModel) -> float:
     cumsum_pred_norm = cumsum_pred / np.max(cumsum_pred)
 
     # Compute area under the Lorenz curve
-    area_lorenz = np.trapz(cumsum_pred_norm, x=cumsum_true_norm)
+    area_lorenz = _trapezoid(cumsum_pred_norm, x=cumsum_true_norm)
 
     # Compute Gini coefficient
     return 1 - 2 * area_lorenz

{validmind-2.13.11 → validmind-2.13.13}/validmind/vm_models/result/result.py

@@ -542,6 +542,18 @@ class TestResult(Result):
 
         return serialized
 
+    def _pre_serialize_figures(self):
+        """Render figure PNGs before any upload request starts.
+
+        Kaleido launches a Chromium per figure and blocks the event loop while it
+        runs. Rendering while uploads are in flight lets the request timeout
+        expire on them, and with older kaleido it conflicted with asyncio
+        outright (ZD-626). log() calls this outside the loop; log_async() calls
+        it too because the test-suite runner awaits log_async() directly.
+        """
+        for figure in self.figures or []:
+            figure.pre_serialize()
+
     async def log_async(
         self,
         section_id: str = None,
@@ -553,6 +565,8 @@ class TestResult(Result):
         if self._is_scorer_result:
             return
 
+        self._pre_serialize_figures()
+
         tasks = []  # collect tasks to run in parallel (async)
 
         # Default empty dict if None
@@ -680,10 +694,7 @@ class TestResult(Result):
         if section_id:
             self._validate_section_id_for_block(section_id, position)
 
-        # Pre-serialize figures before entering async context to avoid conflicts
-        # between Plotly's kaleido library and asyncio event loops (ZD-626)
-        for figure in self.figures or []:
-            figure.pre_serialize()
+        self._pre_serialize_figures()
 
         run_async(
             self.log_async,

validmind-2.13.11/validmind/__version__.py

@@ -1 +0,0 @@
-__version__ = "2.13.11"