validmind 2.13.8__tar.gz → 2.13.11__tar.gz

{validmind-2.13.8 → validmind-2.13.11}/.gitignore

@@ -189,12 +189,8 @@ lending_club_loan_data_*.csv
 
 # Pickle files
 *.pkl
-# Sample application scorecard model for validation notebook — do not remove!
-!notebooks/use_cases/validation/xgb_model_champion.pkl
 # Sample logistic regression model for validation series — do not remove!
 !notebooks/tutorials/validation/lr_model_champion.pkl
-# Sample XGBoost model for validation quickstart — do not remove!
-!notebooks/quickstart/xgboost_model_champion.pkl
 
 notebooks/llm/datasets/*.jsonl
 

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: validmind
-Version: 2.13.8
+Version: 2.13.11
 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
@@ -735,6 +735,7 @@ Requires-Dist: pyarrow<23,>=22; (python_version >= '3.14') and extra == 'all'
 Requires-Dist: pycocoevalcap; extra == 'all'
 Requires-Dist: ragas<=0.2.7,>=0.2.3; extra == 'all'
 Requires-Dist: rouge>=1; extra == 'all'
+Requires-Dist: scikit-learn<1.8; extra == 'all'
 Requires-Dist: scipy; extra == 'all'
 Requires-Dist: scorecardpy==0.1.9.6; extra == 'all'
 Requires-Dist: sentencepiece<0.3.0,>=0.2.0; extra == 'all'
@@ -744,7 +745,7 @@ Requires-Dist: statsmodels<0.15.0,>=0.14.2; extra == 'all'
 Requires-Dist: textblob<0.19.0,>=0.18.0.post0; extra == 'all'
 Requires-Dist: torch>=2.0.0; extra == 'all'
 Requires-Dist: transformers<5.0.0,>=4.32.0; extra == 'all'
-Requires-Dist: xgboost<3,>=1.5.2; extra == 'all'
+Requires-Dist: xgboost<3.1,>=1.5.2; extra == 'all'
 Provides-Extra: credit-risk
 Requires-Dist: scorecardpy==0.1.9.6; extra == 'credit-risk'
 Requires-Dist: setuptools<82; extra == 'credit-risk'
@@ -802,7 +803,8 @@ Requires-Dist: arch>=7.0.0; extra == 'stats'
 Requires-Dist: scipy; extra == 'stats'
 Requires-Dist: statsmodels<0.15.0,>=0.14.2; extra == 'stats'
 Provides-Extra: xgboost
-Requires-Dist: xgboost<3,>=1.5.2; extra == 'xgboost'
+Requires-Dist: scikit-learn<1.8; extra == 'xgboost'
+Requires-Dist: xgboost<3.1,>=1.5.2; extra == 'xgboost'
 Description-Content-Type: text/markdown
 
 # ValidMind Library

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

@@ -1,6 +1,6 @@
 [project]
 name = "validmind"
-version = "2.13.8"
+version = "2.13.11"
 description = "ValidMind Library"
 readme = "README.pypi.md"
 requires-python = ">=3.9,<3.15"
@@ -40,7 +40,8 @@ dependencies = [
 [project.optional-dependencies]
 all = [
   "torch (>=2.0.0)",
-  "xgboost (>=1.5.2,<3)",
+  "xgboost (>=1.5.2,<3.1)",
+  "scikit-learn (<1.8)",
   "transformers (>=4.32.0,<5.0.0)",
   "pycocoevalcap",
   "ragas (>=0.2.3,<=0.2.7)",
@@ -108,7 +109,10 @@ nlp = [
 ]
 pytorch = ["torch (>=2.0.0)"]
 stats = ["scipy", "statsmodels (>=0.14.2,<0.15.0)", "arch (>=7.0.0)"]
-xgboost = ["xgboost (>=1.5.2,<3)"]
+xgboost = [
+  "xgboost (>=1.5.2,<3.1)",
+  "scikit-learn (<1.8)",
+]
 explainability = [
   "shap (>=0.46.0)",
   "numba (>=0.65.1) ; python_version >= '3.14'",

validmind-2.13.11/validmind/__version__.py

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

{validmind-2.13.8 → validmind-2.13.11}/validmind/ai/utils.py

@@ -8,7 +8,7 @@ import os
 from openai import AzureOpenAI, OpenAI
 
 from ..logging import get_logger
-from ..utils import md_to_html
+from ..utils import is_html, md_to_html
 
 logger = get_logger(__name__)
 
@@ -38,6 +38,7 @@ class DescriptionFuture:
 
     def __init__(self, future):
         self._future = future
+        self.markdown_source = None
 
     def get_description(self):
         if isinstance(self._future, tuple):
@@ -46,7 +47,9 @@ class DescriptionFuture:
             # This will block until the future is completed
             description = self._future.result()
 
-        return md_to_html(description[0], mathml=True), description[1]
+        source, was_generated = description
+        self.markdown_source = source if not is_html(source) else None
+        return md_to_html(source, mathml=True), was_generated
 
 
 def _get_google_api_key():

{validmind-2.13.8 → validmind-2.13.11}/validmind/api_client.py

@@ -11,6 +11,7 @@ import asyncio
 import atexit
 import json
 import os
+import threading
 from io import BytesIO
 from typing import Any, Dict, List, Optional, Tuple, Union
 from urllib.parse import urlencode, urljoin
@@ -42,6 +43,10 @@ _monitoring = False
 _auth_mode = "api_key"
 _access_token: Optional[str] = None
 _oidc_login_context: Optional[Dict[str, str]] = None
+# Expiry (ISO-8601) of the in-memory OIDC access token, for cheap request-path
+# staleness checks; guarded together with the token by _oidc_refresh_lock.
+_oidc_expires_at: Optional[str] = None
+_oidc_refresh_lock = threading.Lock()
 
 __api_session: Optional[aiohttp.ClientSession] = None
 
@@ -147,12 +152,21 @@ def _get_url(
 async def _get(
     endpoint: str, params: Optional[Dict[str, str]] = None
 ) -> Dict[str, Any]:
+    _ensure_fresh_oidc_token()
     url = _get_url(endpoint, params)
     session = _get_session()
 
     async with session.get(url) as r:
+        # A 401 can still slip through if the token was revoked ahead of its
+        # stated expiry; force a refresh and retry once (safe — GET has no body).
+        if r.status == 401 and _ensure_fresh_oidc_token(force=True):
+            session = _get_session()
+            async with session.get(url) as retry:
+                if retry.status != 200:
+                    _raise_for_api_error(retry.status, await retry.text())
+                return await retry.json()
         if r.status != 200:
-            raise_api_error(await r.text())
+            _raise_for_api_error(r.status, await r.text())
 
         return await r.json()
 
@@ -163,6 +177,7 @@ async def _post(
     data: Optional[Union[dict, FormData]] = None,
     files: Optional[Dict[str, Tuple[str, BytesIO, str]]] = None,
 ) -> Dict[str, Any]:
+    _ensure_fresh_oidc_token()
     url = _get_url(endpoint, params)
     session = _get_session()
 
@@ -186,20 +201,29 @@ async def _post(
         _data = data
 
     async with session.post(url, data=_data) as r:
+        # Not retried on 401: the request body / upload stream may already be
+        # consumed. Proactive refresh above covers the expiry case; a 401 here
+        # means a genuinely rejected token, surfaced as a clear auth error.
         if r.status != 200:
-            raise_api_error(await r.text())
+            _raise_for_api_error(r.status, await r.text())
 
         return await r.json()
 
 
 def _ping() -> Dict[str, Any]:
     """Validates that we can connect to the ValidMind API (does not use the async session)."""
+    _ensure_fresh_oidc_token()
     r = requests.get(
         url=_get_url("ping"),
         headers=_get_api_headers(),
     )
+    if r.status_code == 401 and _ensure_fresh_oidc_token(force=True):
+        r = requests.get(
+            url=_get_url("ping"),
+            headers=_get_api_headers(),
+        )
     if r.status_code != 200:
-        raise_api_error(r.text)
+        _raise_for_api_error(r.status_code, r.text)
 
     client_info = r.json()
 
@@ -224,6 +248,36 @@ def _ping() -> Dict[str, Any]:
         )
 
 
+def _refresh_oidc_from_cache(
+    issuer: str,
+    client_id: str,
+    refresh_token: str,
+    scope: Optional[str],
+    audience: Optional[str] = None,
+) -> Optional[Dict[str, Any]]:
+    """Exchange a cached refresh token for new tokens, persisting the result.
+
+    Shared by the ``init()`` path (``_obtain_oidc_tokens``) and the request path
+    (``_ensure_fresh_oidc_token``) so their refresh behaviour can't drift. On
+    success the refreshed entry is cached and returned. On a failed refresh (e.g.
+    revoked token / ``invalid_grant``) the stale entry is deleted and None is
+    returned, so a dead refresh token isn't re-attempted; the caller decides how
+    to recover (``init()`` falls back to device flow, the request path stops).
+    """
+    from .credentials_store import delete_cached_entry, upsert_cached_entry
+    from .oidc_device import try_refresh_cached_tokens
+
+    try:
+        new_tokens = try_refresh_cached_tokens(
+            issuer, client_id, refresh_token, scope, audience=audience
+        )
+    except ValidMindAuthError:
+        delete_cached_entry(issuer, client_id, audience=audience)
+        return None
+    upsert_cached_entry(issuer, client_id, new_tokens, audience=audience)
+    return new_tokens
+
+
 def _obtain_oidc_tokens(
     issuer: str,
     client_id: str,
@@ -232,14 +286,13 @@ def _obtain_oidc_tokens(
 ) -> Dict[str, Any]:
     """Return a credentials entry dict with access_token, expires_at, refresh_token, etc."""
     from .credentials_store import (
-        delete_cached_entry,
         get_cached_entry,
         is_expired,
         normalize_client_id,
         normalize_issuer,
         upsert_cached_entry,
     )
-    from .oidc_device import run_device_flow, try_refresh_cached_tokens
+    from .oidc_device import run_device_flow
 
     norm_issuer = normalize_issuer(issuer)
     norm_client_id = normalize_client_id(client_id)
@@ -247,20 +300,11 @@ def _obtain_oidc_tokens(
     if cached and not is_expired(cached):
         return cached
     if cached and cached.get("refresh_token"):
-        try:
-            new_tokens = try_refresh_cached_tokens(
-                norm_issuer,
-                norm_client_id,
-                cached["refresh_token"],
-                scope,
-                audience=audience,
-            )
-            upsert_cached_entry(
-                norm_issuer, norm_client_id, new_tokens, audience=audience
-            )
+        new_tokens = _refresh_oidc_from_cache(
+            norm_issuer, norm_client_id, cached["refresh_token"], scope, audience
+        )
+        if new_tokens is not None:
             return new_tokens
-        except ValidMindAuthError:
-            delete_cached_entry(norm_issuer, norm_client_id, audience=audience)
     tokens = run_device_flow(norm_issuer, norm_client_id, scope, audience=audience)
     upsert_cached_entry(norm_issuer, norm_client_id, tokens, audience=audience)
     return tokens
@@ -276,6 +320,100 @@ def _select_oidc_bearer_token(entry: Dict[str, Any]) -> str:
     return entry["access_token"]
 
 
+def _set_oidc_access_token(entry: Dict[str, Any]) -> None:
+    """Adopt the bearer token from a credentials entry as the active token.
+
+    Records its expiry for cheap request-path staleness checks and drops the
+    pooled aiohttp session so the next request rebuilds it with the new token.
+    """
+    global _access_token, _oidc_expires_at
+    _access_token = _select_oidc_bearer_token(entry)
+    _oidc_expires_at = entry.get("expires_at")
+    _invalidate_async_session()
+
+
+def _clear_oidc_access_token() -> None:
+    """Drop the in-memory OIDC token and pooled session after an unrecoverable refresh.
+
+    Pairs with deleting the cached entry: with no usable token in memory, the next
+    request fails fast at header build with the clear "run vm.init()" error instead
+    of sending a doomed request just to get a 401 back.
+    """
+    global _access_token, _oidc_expires_at
+    _access_token = None
+    _oidc_expires_at = None
+    _invalidate_async_session()
+
+
+def _oidc_token_is_stale() -> bool:
+    """Cheap in-memory expiry check (no file I/O) using the 120s skew in is_expired."""
+    from .credentials_store import is_expired
+
+    return is_expired({"expires_at": _oidc_expires_at})
+
+
+def _ensure_fresh_oidc_token(force: bool = False) -> bool:
+    """Refresh the OIDC access token on the request path when it has expired.
+
+    The token captured at ``init()`` is otherwise reused unchanged for the life of
+    the process, so a session that outlives the provider's access-token lifetime
+    starts failing on every call until ``init()`` is re-run. This uses the cached
+    refresh token (requires ``offline_access``, the default scope) to obtain a new
+    access token in place. Returns True when a usable token is in place, False when
+    no refresh was possible (non-OIDC mode, no cached refresh token, or a failed
+    refresh — in which case the cached entry is dropped, matching init()).
+    """
+    if _auth_mode != "oidc" or _oidc_login_context is None:
+        return False
+    # Hot path: skip file I/O and the lock while the current token is still valid.
+    if not force and not _oidc_token_is_stale():
+        return True
+
+    from .credentials_store import get_cached_entry, is_expired
+
+    ctx = _oidc_login_context
+    issuer = ctx["issuer"]
+    client_id = ctx["client_id"]
+    scope = ctx.get("scope")
+    audience = ctx.get("audience") or None
+
+    with _oidc_refresh_lock:
+        entry = get_cached_entry(issuer, client_id, audience=audience)
+        if entry is None:
+            return False
+        # Another caller may have refreshed the token while we waited on the lock.
+        if not force and not is_expired(entry):
+            _set_oidc_access_token(entry)
+            return True
+        refresh_token = entry.get("refresh_token")
+        if not refresh_token:
+            return False
+        # Shared with init(): on failure the cached entry is dropped so a
+        # bad/revoked refresh token isn't re-attempted on every request. Recovery
+        # is re-running vm.init() (surfaced by the clear 401 auth error); unlike
+        # init() the request path can't fall back to interactive device flow.
+        new_tokens = _refresh_oidc_from_cache(
+            issuer, client_id, refresh_token, scope, audience
+        )
+        if new_tokens is None:
+            # Hard failure: the cache entry was dropped; clear the in-memory token
+            # too so the next request fails fast with the clear re-auth message.
+            _clear_oidc_access_token()
+            return False
+        _set_oidc_access_token(new_tokens)
+        return True
+
+
+def _raise_for_api_error(status: int, text: str) -> None:
+    """Raise a clear, actionable auth error for an OIDC 401, else defer to raise_api_error."""
+    if status == 401 and _auth_mode == "oidc":
+        raise ValidMindAuthError(
+            "ValidMind rejected the OAuth access token (HTTP 401); it may have "
+            "expired or been revoked. Run vm.init() again to re-authenticate."
+        )
+    raise_api_error(text)
+
+
 def init(
     api_key: Optional[str] = None,
     api_secret: Optional[str] = None,
@@ -330,7 +468,7 @@ def init(
         ValidMindAuthError: If OIDC configuration conflicts or login fails.
     """
     global _api_key, _api_secret, _api_host, _model_cuid, _monitoring, _document
-    global _auth_mode, _access_token, _oidc_login_context
+    global _auth_mode, _access_token, _oidc_login_context, _oidc_expires_at
 
     if api_key == "...":
         # special case to detect when running a notebook placeholder (...)
@@ -402,20 +540,21 @@ def init(
         entry = _obtain_oidc_tokens(
             oidc_issuer, oidc_client_id, scope_val, audience=oidc_audience_opt
         )
-        _access_token = _select_oidc_bearer_token(entry)
         _oidc_login_context = {
             "issuer": entry["issuer"],
             "client_id": entry["client_id"],
             "scope": scope_val,
             "audience": entry.get("audience") or oidc_audience_val,
         }
-        _invalidate_async_session()
+        # Sets _access_token / _oidc_expires_at and invalidates the async session.
+        _set_oidc_access_token(entry)
     else:
         if env_key is None or env_secret is None:
             raise MissingAPICredentialsError()
         _auth_mode = "api_key"
         _access_token = None
         _oidc_login_context = None
+        _oidc_expires_at = None
         _api_key = env_key
         _api_secret = env_secret
         _api_host = resolved_host
@@ -449,6 +588,7 @@ async def alog_metadata(
     text: Optional[str] = None,
     _json: Optional[Dict[str, Any]] = None,
     section_id: Optional[str] = None,
+    text_format: Optional[str] = None,
 ) -> Dict[str, Any]:
     """Logs free-form metadata to ValidMind API.
 
@@ -458,6 +598,9 @@ async def alog_metadata(
         _json (dict, optional): Free-form key-value pairs to assign to the metadata. Defaults to None.
         section_id (str, optional): Section ID to append the text block to when the
             content ID does not already exist.
+        text_format (str, optional): Format of ``text``. Markdown is sent as-is when
+            the backend advertises support so conversion happens after the request
+            passes through the WAF. Older backends receive locally converted HTML.
 
     Raises:
         Exception: If the API call fails.
@@ -465,11 +608,17 @@ async def alog_metadata(
     Returns:
         dict: The response from the API.
     """
+    if text_format == "markdown" and not client_config.supports_log_metadata_markdown():
+        text = md_to_html(text, mathml=True)
+        text_format = None
+
     metadata_dict = {"content_id": content_id}
     if text is not None:
         metadata_dict["text"] = text
     if _json is not None:
         metadata_dict["json"] = _json
+    if text_format is not None:
+        metadata_dict["text_format"] = text_format
 
     request_params = {}
     if section_id:
@@ -656,6 +805,7 @@ def _validate_log_text_context(
 
 def generate_qualitative_text(text_generation_data: Dict[str, Any]) -> Dict[str, Any]:
     """Generate qualitative text using the ValidMind AI API."""
+    _ensure_fresh_oidc_token()
     r = requests.post(
         url=_get_url("ai/generate/qualitative_text_generation"),
         headers=_get_api_headers(),
@@ -663,16 +813,23 @@ def generate_qualitative_text(text_generation_data: Dict[str, Any]) -> Dict[str,
     )
 
     if r.status_code != 200:
-        raise_api_error(r.text)
+        _raise_for_api_error(r.status_code, r.text)
 
     return r.json()
 
 
-def _normalize_logged_text(text: str, field_name: str) -> str:
-    """Validate text content and convert Markdown to HTML when needed."""
+def _validate_logged_text(text: str, field_name: str) -> str:
+    """Validate text accepted by log_text."""
     if not isinstance(text, str) or not text:
         raise ValueError(f"`{field_name}` must be a non-empty string")
 
+    return text
+
+
+def _normalize_logged_text(text: str, field_name: str) -> str:
+    """Validate text content and convert Markdown to HTML for local rendering."""
+    text = _validate_logged_text(text, field_name)
+
     if not is_html(text):
         return md_to_html(text, mathml=True)
 
@@ -688,7 +845,7 @@ def _validate_manual_log_text_args(
     if context is not None:
         raise ValueError("`context` is only supported when `text` is omitted")
 
-    return _normalize_logged_text(text, "text")
+    return _validate_logged_text(text, "text")
 
 
 def _build_log_text_generation_request(
@@ -720,13 +877,13 @@ def _build_log_text_generation_request(
     return request_data
 
 
-def _generate_log_text(
+def _generate_log_text_source(
     content_id: str,
     prompt: Optional[str],
     context: Optional[Dict[str, Any]],
     section_id: Optional[str] = None,
 ) -> str:
-    """Generate text for log_text and normalize it to HTML."""
+    """Generate and validate source text without converting it to HTML."""
     request_data = _build_log_text_generation_request(
         content_id,
         prompt,
@@ -734,6 +891,22 @@ def _generate_log_text(
         section_id=section_id,
     )
     generated_text = generate_qualitative_text(request_data)["content"]
+    return _validate_logged_text(generated_text, "generated text")
+
+
+def _generate_log_text(
+    content_id: str,
+    prompt: Optional[str],
+    context: Optional[Dict[str, Any]],
+    section_id: Optional[str] = None,
+) -> str:
+    """Generate text and normalize it to HTML for local result rendering."""
+    generated_text = _generate_log_text_source(
+        content_id,
+        prompt,
+        context,
+        section_id=section_id,
+    )
     return _normalize_logged_text(generated_text, "generated text")
 
 
@@ -762,14 +935,21 @@ async def alog_text(
     if text is not None:
         text = _validate_manual_log_text_args(text, prompt, context)
     else:
-        text = _generate_log_text(
+        text = _generate_log_text_source(
             content_id,
             prompt,
             context,
             section_id=section_id,
         )
 
-    return await alog_metadata(content_id, text, _json, section_id=section_id)
+    text_format = None if is_html(text) else "markdown"
+    return await alog_metadata(
+        content_id,
+        text,
+        _json,
+        section_id=section_id,
+        text_format=text_format,
+    )
 
 
 def log_text(
@@ -784,9 +964,9 @@ def log_text(
 
     Args:
         content_id (str): Unique content identifier for the text.
-        text (str, optional): The text to log. Will be converted to HTML with
-            MathML support when Markdown is provided. If omitted, text is
-            generated using the qualitative text generation backend.
+        text (str, optional): The text to log. Markdown is sent to the backend for
+            HTML and math conversion. If omitted, text is generated using the
+            qualitative text generation backend.
         prompt (str, optional): Custom prompt used for AI-assisted text
             generation. Only supported when `text` is omitted.
         context (dict, optional): Context object for AI-assisted text
@@ -901,6 +1081,7 @@ def log_metric(
 
 
 def generate_test_result_description(test_result_data: Dict[str, Any]) -> str:
+    _ensure_fresh_oidc_token()
     r = requests.post(
         url=_get_url("ai/generate/test_result_description"),
         headers=_get_api_headers(),
@@ -908,6 +1089,6 @@ def generate_test_result_description(test_result_data: Dict[str, Any]) -> str:
     )
 
     if r.status_code != 200:
-        raise_api_error(r.text)
+        _raise_for_api_error(r.status_code, r.text)
 
     return r.json()

{validmind-2.13.8 → validmind-2.13.11}/validmind/client.py

@@ -38,7 +38,7 @@ from .template import preview_template as _preview_template
 from .test_suites import get_by_id as get_test_suite_by_id
 from .tests.run import _get_run_metadata
 from .utils import display as vm_display
-from .utils import get_dataset_info, get_model_info
+from .utils import get_dataset_info, get_model_info, is_html
 from .vm_models import TestSuite, TestSuiteRunner
 from .vm_models.dataset import DataFrameDataset, PolarsDataset, TorchDataset, VMDataset
 from .vm_models.html_progress import HTMLLabel, HTMLProgressBar
@@ -479,9 +479,12 @@ def run_text_generation(
         A TextGenerationResult containing the generated text.
     """
     start_time = time.perf_counter()
-    description = api_client._generate_log_text(
+    description_source = api_client._generate_log_text_source(
         content_id, prompt, context, section_id=section_id
     )
+    description = api_client._normalize_logged_text(
+        description_source, "generated text"
+    )
     metadata = _get_run_metadata(duration_seconds=time.perf_counter() - start_time)
     result = TextGenerationResult(
         result_id=content_id,
@@ -494,6 +497,9 @@ def run_text_generation(
         section_id=section_id,
         context=context,
         _was_description_generated=True,
+        _description_source=(
+            description_source if not is_html(description_source) else None
+        ),
     )
 
     if show:

{validmind-2.13.8 → validmind-2.13.11}/validmind/client_config.py

@@ -39,6 +39,10 @@ class ClientConfig:
         """Returns True if the client can generate LLM-based test descriptions."""
         return self.feature_flags.get("llm_test_descriptions", True)
 
+    def supports_log_metadata_markdown(self):
+        """Return whether the backend converts Markdown logged as metadata."""
+        return self.feature_flags.get("log_metadata_markdown", False)
+
 
 client_config = ClientConfig(
     model=None,

{validmind-2.13.8 → validmind-2.13.11}/validmind/experimental/agents.py

@@ -54,7 +54,8 @@ def run_task(
     else:
         raise ValueError(f"Unsupported task: {task}")
 
-    if not is_html(generated_text):
+    description_source = generated_text if not is_html(generated_text) else None
+    if description_source is not None:
         generated_text = md_to_html(generated_text, mathml=True)
 
     # Create a test result with the generated text
@@ -68,6 +69,7 @@ def run_task(
         section_id=input.get("section_id"),
         context=input.get("context"),
         _was_description_generated=True,
+        _description_source=description_source,
     )
     if show:
         result.show()

{validmind-2.13.8 → validmind-2.13.11}/validmind/tests/model_validation/sklearn/CalibrationCurve.py

@@ -2,6 +2,7 @@
 # Refer to the LICENSE file in the root of this repository for details.
 # SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial
 
+import inspect
 from typing import Tuple
 
 import numpy as np
@@ -80,8 +81,19 @@ def CalibrationCurve(
             "Calibration Curve is only supported for binary classification models"
         )
 
+    # A two-class target encoded outside {0, 1} (e.g. {0, 4} or string labels)
+    # passes the guard above but hits sklearn's "pos_label is not specified" error.
+    # Pass the largest label as the positive class, matching the "largest label is
+    # positive" convention in _diagnosis_metrics.resolve_averaging; for {0, 1} this
+    # is byte-identical to sklearn's default. pos_label was added to
+    # calibration_curve in scikit-learn 1.1, so guard by signature inspection to
+    # keep pre-1.1 installs working (pyproject sets no scikit-learn floor).
+    kwargs = {}
+    if "pos_label" in inspect.signature(calibration_curve).parameters:
+        kwargs["pos_label"] = np.unique(dataset.y).max()
+
     prob_true, prob_pred = calibration_curve(
-        dataset.y, dataset.y_prob(model), n_bins=n_bins
+        dataset.y, dataset.y_prob(model), n_bins=n_bins, **kwargs
     )
 
     # Create DataFrame for raw data