validmind 2.13.14__tar.gz → 2.14.0__tar.gz

{validmind-2.13.14 → validmind-2.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: validmind
-Version: 2.13.14
+Version: 2.14.0
 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.14 → validmind-2.14.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "validmind"
-version = "2.13.14"
+version = "2.14.0"
 description = "ValidMind Library"
 readme = "README.pypi.md"
 requires-python = ">=3.9,<3.15"
@@ -195,3 +195,6 @@ profile = "black"
 
 [tool.uv]
 exclude-newer = "7 days"
+exclude-newer-package = { certifi = "2026-10-21" }
+# Security floor: certifi>=2026.10.19 distrusts compromised eMudhra intermediates (Mozilla bug 2083449)
+constraint-dependencies = ["certifi>=2026.10.19"]

validmind-2.14.0/validmind/__version__.py

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

{validmind-2.13.14 → validmind-2.14.0}/validmind/api_client.py

@@ -19,6 +19,7 @@ from urllib.parse import urlencode, urljoin
 import aiohttp
 import requests
 from aiohttp import FormData
+from packaging.version import Version
 
 from .__version__ import __version__
 from .client_config import client_config
@@ -247,6 +248,46 @@ def _ping() -> Dict[str, Any]:
             f"📁 Document Type: {client_config.document_type}"
         )
 
+    # Every successful ping, not only the first: reconnecting or switching
+    # models must still warn.
+    _log_ping_messages(client_info.get("messages"))
+
+
+def _ping_message_applies(message: Dict[str, Any]) -> bool:
+    """Whether a /ping message targets this library version.
+
+    ``if_client_version_lte`` missing or null means every version. Uses
+    ``packaging.version`` rather than ``utils.parse_version``, which drops
+    pre- and post-release parts.
+    """
+    cutoff = message.get("if_client_version_lte")
+    if cutoff is None:
+        return True
+    return Version(__version__) <= Version(str(cutoff))
+
+
+def _log_ping_messages(messages: Any) -> None:
+    """Log the platform messages returned by /ping as warnings, one line each.
+
+    Parsed defensively: a missing or malformed ``messages`` value, a bad entry
+    or an unparseable version cutoff is skipped quietly and never fails
+    ``vm.init()``. ``type``, ``severity`` and ``action`` aren't interpreted.
+    """
+    if not isinstance(messages, list):
+        return
+
+    for message in messages:
+        try:
+            text = message.get("message") if isinstance(message, dict) else None
+            if not isinstance(text, str) or not text.strip():
+                logger.debug(f"Ignoring malformed /ping message: {message!r}")
+                continue
+            if not _ping_message_applies(message):
+                continue
+            logger.warning(" ".join(text.split()))
+        except Exception:
+            logger.debug(f"Ignoring malformed /ping message: {message!r}")
+
 
 def _refresh_oidc_from_cache(
     issuer: str,

{validmind-2.13.14 → validmind-2.14.0}/validmind/tests/decorator.py

@@ -103,7 +103,9 @@ def test(func_or_id: Union[Callable[..., Any], str, None]) -> Callable[[F], F]:
 
     The function should return one of the following types:
 
-    - Table: Either a list of dictionaries or a pandas DataFrame
+    - Table: A list of dictionaries, a pandas DataFrame, or a pandas Styler
+      (see `validmind.vm_models.result.ResultTable` for how cell styles are
+      preserved)
     - Plot: Either a matplotlib figure or a plotly figure
     - Scalar: A single number (int or float)
     - Boolean: A single boolean value indicating whether the test passed or failed
@@ -206,7 +208,9 @@ def scorer(func_or_id: Union[Callable[..., Any], str, None] = None) -> Callable[
 
     The function should return one of the following types:
 
-    - Table: Either a list of dictionaries or a pandas DataFrame
+    - Table: A list of dictionaries, a pandas DataFrame, or a pandas Styler
+      (see `validmind.vm_models.result.ResultTable` for how cell styles are
+      preserved)
     - Plot: Either a matplotlib figure or a plotly figure
     - Scalar: A single number (int or float)
     - Boolean: A single boolean value indicating whether the test passed or failed

{validmind-2.13.14 → validmind-2.14.0}/validmind/tests/load.py

@@ -21,6 +21,7 @@ from typing import (
 from uuid import uuid4
 
 import pandas as pd
+from pandas.io.formats.style import Styler
 
 from ..errors import LoadTestError, MissingDependencyError
 from ..html_templates.content_blocks import test_content_block_html
@@ -49,7 +50,7 @@ except ImportError:
 FIGURE_TYPES = tuple(
     item for item in (Figure, MatplotlibFigure, PlotlyFigure) if inspect.isclass(item)
 )
-TABLE_TYPES = (pd.DataFrame, ResultTable)
+TABLE_TYPES = (pd.DataFrame, Styler, ResultTable)
 GENERIC_TABLE_TYPES = (list, dict)
 
 
@@ -450,7 +451,7 @@ def describe_test(
     html = test_content_block_html.format(
         test_id=test_id,
         uuid=str(uuid4()),
-        title=f'{details["Name"]}',
+        title=f"{details['Name']}",
         description=md_to_html(details["Description"].strip()),
         required_inputs=", ".join(details["Required Inputs"] or ["None"]),
         params_table="\n".join(

{validmind-2.13.14 → validmind-2.14.0}/validmind/tests/output.py

@@ -8,6 +8,7 @@ from uuid import uuid4
 
 import numpy as np
 import pandas as pd
+from pandas.io.formats.style import Styler
 
 from validmind.utils import is_html, md_to_html
 from validmind.vm_models.figure import (
@@ -102,7 +103,48 @@ class FigureOutputHandler(OutputHandler):
 
 class TableOutputHandler(OutputHandler):
     def can_handle(self, item: Any) -> bool:
-        return isinstance(item, (list, pd.DataFrame, dict, ResultTable, tuple))
+        return isinstance(item, (list, pd.DataFrame, Styler, dict, ResultTable, tuple))
+
+    def _convert_styler(self, styler: Styler) -> pd.DataFrame:
+        """Convert a pandas Styler to a DataFrame with portable cell styles."""
+        styler._compute()
+
+        # Round while still numeric: ResultTable's .round(4) is a no-op on the
+        # object dtype we need below, so it would otherwise silently skip the
+        # whole table. Formatters still see the original, unrounded value.
+        source = styler.data
+        df = source.round(4).astype(object)
+        display_funcs = getattr(styler, "_display_funcs", {})
+
+        style_key_map = {
+            "background": "bgcolor",
+            "background-color": "bgcolor",
+            "color": "color",
+            "font-weight": "fontWeight",
+            "text-align": "textAlign",
+        }
+
+        for (row_idx, col_idx), styles in styler.ctx.items():
+            cell_styles = {}
+
+            for css_property, css_value in styles:
+                style_key = style_key_map.get(css_property.lower())
+                if style_key and css_value:
+                    cell_styles[style_key] = css_value
+
+            if not cell_styles:
+                continue
+
+            formatter = display_funcs.get((row_idx, col_idx))
+            value = (
+                formatter(source.iat[row_idx, col_idx])
+                if formatter
+                else df.iat[row_idx, col_idx]
+            )
+
+            df.iat[row_idx, col_idx] = {"value": value, **cell_styles}
+
+        return df
 
     def _convert_simple_type(self, data: Any) -> pd.DataFrame:
         """Convert a simple data type to a DataFrame."""
@@ -135,6 +177,8 @@ class TableOutputHandler(OutputHandler):
         # Handle special cases by type
         if isinstance(table_data, pd.DataFrame):
             return table_data
+        elif isinstance(table_data, Styler):
+            return self._convert_styler(table_data)
         elif isinstance(table_data, (dict, str, type(None))):
             return self._convert_simple_type(table_data)
         elif isinstance(table_data, tuple):
@@ -150,7 +194,13 @@ class TableOutputHandler(OutputHandler):
     def process(
         self,
         item: Union[
-            List[Dict[str, Any]], pd.DataFrame, Dict[str, Any], ResultTable, str, tuple
+            List[Dict[str, Any]],
+            pd.DataFrame,
+            Styler,
+            Dict[str, Any],
+            ResultTable,
+            str,
+            tuple,
         ],
         result: TestResult,
     ) -> None:

{validmind-2.13.14 → validmind-2.14.0}/validmind/utils.py

@@ -259,17 +259,19 @@ def format_records(df: pd.DataFrame) -> List[Dict[str, Any]]:
 
     We do this for display purposes before sending data to ValidMind. Rules:
 
-    - Check if we are rendering "big" numbers greater than 10 or just numbers between 0 and 1
-    - If the column's smallest number has more decimals 6, use that number's precision
-      so we can avoid rendering a 0 instead
-    - If the column's smallest number has less decimals than 6, use 6 decimal places
+    - Non-numeric columns (text in any dtype, datetimes, categoricals) are left unchanged
+    - Rounding is decided by the column's smallest non-zero number
+    - If it is 10 or greater, round to 2 decimal places
+    - If it has more than 4 decimals, round to 4 decimal places
+    - Otherwise round to that number's own decimal places
+    - If that number is missing or infinite, round to 4 decimal places
     """
     for col in df.columns:
-        if df[col].dtype == "object":
+        if not pd.api.types.is_numeric_dtype(df[col]):
             continue
         not_zero = df[col][df[col] != 0]
         min_number = not_zero.min()
-        if math.isnan(min_number) or math.isinf(min_number):
+        if pd.isna(min_number) or math.isinf(min_number):
             df[col] = df[col].round(DEFAULT_SMALL_NUMBER_DECIMALS)
             continue
 

{validmind-2.13.14 → validmind-2.14.0}/validmind/vm_models/html_renderer.py

@@ -6,6 +6,7 @@
 HTML renderer for ValidMind components that preserves state in saved notebooks.
 """
 
+import html
 import json
 import uuid
 from typing import Any, Dict, List, Optional, Union
@@ -19,6 +20,41 @@ class StatefulHTMLRenderer:
     # Plotly.js CDN URL - using a stable version
     PLOTLY_CDN_URL = "https://cdn.plot.ly/plotly-2.27.0.min.js"
 
+    @staticmethod
+    def _render_table_cell(value: Any) -> Any:
+        """Render structured table cells as HTML for notebook display."""
+        if not isinstance(value, dict) or "value" not in value:
+            # pandas requires formatters to return strings. A column that holds
+            # a styled cell is object dtype, so there is no column-wide float
+            # padding to match; plain cells here render with str() on purpose.
+            return str(value)
+
+        css_properties = {
+            "bgcolor": "background-color",
+            "backgroundColor": "background-color",
+            "color": "color",
+            "fontWeight": "font-weight",
+            "textAlign": "text-align",
+        }
+        styles = []
+
+        for key, css_property in css_properties.items():
+            css_value = value.get(key)
+            if css_value is not None:
+                styles.append(f"{css_property}: {html.escape(str(css_value))}")
+
+        styles.extend(
+            [
+                "display: block",
+                "margin: -8px",
+                "padding: 8px",
+                "min-height: 22px",
+            ]
+        )
+
+        cell_value = html.escape(str(value["value"]))
+        return f'<div style="{"; ".join(styles)}">{cell_value}</div>'
+
     @staticmethod
     def _get_progress_css() -> str:
         """Get the CSS styles required for progress bars."""
@@ -150,11 +186,20 @@ class StatefulHTMLRenderer:
 
         title_html = f"<h4>{title}</h4>" if title else ""
 
+        # Only columns holding a styled cell get the formatter, so plain
+        # columns keep pandas' default rendering exactly as before.
+        formatters = {
+            column: StatefulHTMLRenderer._render_table_cell
+            for position, column in enumerate(data.columns)
+            if any(isinstance(cell, dict) for cell in data.iloc[:, position])
+        }
+
         # Convert DataFrame to HTML with styling
         table_html = data.to_html(
             classes="vm-table table table-striped table-hover",
             table_id=table_id,
             escape=False,
+            formatters=formatters,
             index=False,
         )
 
@@ -206,7 +251,7 @@ class StatefulHTMLRenderer:
 
         return f"""
         <div class="vm-accordion" id="{accordion_id}">
-            {''.join(accordion_items)}
+            {"".join(accordion_items)}
         </div>
 
         <script>
@@ -293,7 +338,7 @@ class StatefulHTMLRenderer:
 
         <script>
         // Create global update functions for this progress bar
-        window.updateProgress_{bar_id.replace('-', '_')} = function(value, description) {{
+        window.updateProgress_{bar_id.replace("-", "_")} = function(value, description) {{
             var maxValue = {max_value};
             var percentage = (value / maxValue * 100);
 
@@ -306,7 +351,7 @@ class StatefulHTMLRenderer:
             if (descElement && description) descElement.innerHTML = description;
         }};
 
-        window.completeProgress_{bar_id.replace('-', '_')} = function() {{
+        window.completeProgress_{bar_id.replace("-", "_")} = function() {{
             var descElement = document.getElementById('{bar_id}-description');
             if (descElement) descElement.innerHTML = 'Test suite complete!';
         }};

{validmind-2.13.14 → validmind-2.14.0}/validmind/vm_models/result/pii_filter.py

@@ -168,7 +168,7 @@ def scan_df(df: pd.DataFrame) -> bool:
         return True
 
     # Scan all string/object columns
-    columns = [col for col in df.columns if df[col].dtype == "object"]
+    columns = [col for col in df.columns if pd.api.types.is_string_dtype(df[col].dtype)]
 
     if not columns:
         return True

{validmind-2.13.14 → validmind-2.14.0}/validmind/vm_models/result/result.py

@@ -113,6 +113,22 @@ class ResultTable:
         title: Optional caption/title for the table. When set, it is sent to
             the platform as ``metadata.caption`` and rendered by the document
             media registry as ``Table N. <title>``.
+
+    Styled cells
+    ------------
+    A cell is normally a plain scalar. Tests that return a ``pandas.Styler``
+    produce *styled* cells for the subset of cells that have supported CSS
+    applied; those cells are dicts of the form::
+
+        {"value": <display value>, "bgcolor": ..., "color": ...,
+         "fontWeight": ..., "textAlign": ...}
+
+    Only the keys that were actually styled are present, so a single column may
+    mix scalars and dicts. ``value`` is the Styler's formatted display value
+    when a formatter is registered, and the original value otherwise. The CSS
+    values are passed through verbatim from the test author. This schema is
+    shared with the platform, which renders it in the documentation UI and in
+    HTML/DOCX exports. See ``validmind.tests.output.TableOutputHandler``.
     """
 
     data: Union[List[Any], pd.DataFrame]

validmind-2.13.14/validmind/__version__.py

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