evo-widgets 0.2.2__tar.gz → 0.2.3__tar.gz

{evo_widgets-0.2.2 → evo_widgets-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: evo-widgets
-Version: 0.2.2
+Version: 0.2.3
 Summary: Widgets and presentation layer for Evo SDK - HTML rendering and IPython formatters for Jupyter notebooks
 Project-URL: Source, https://github.com/SeequentEvo/evo-python-sdk
 Project-URL: Tracker, https://github.com/SeequentEvo/evo-python-sdk/issues

{evo_widgets-0.2.2 → evo_widgets-0.2.3}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "evo-widgets"
 description = "Widgets and presentation layer for Evo SDK - HTML rendering and IPython formatters for Jupyter notebooks"
-version = "0.2.2"
+version = "0.2.3"
 requires-python = ">=3.10"
 license-files = ["LICENSE.md"]
 dynamic = ["readme"]

{evo_widgets-0.2.2 → evo_widgets-0.2.3}/src/evo/widgets/__init__.py

@@ -34,6 +34,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from .formatters import (
+    _TASK_RESULT_FORMATTERS,
     format_attributes_collection,
     format_base_object,
     format_block_model,
@@ -96,6 +97,13 @@ __all__ = [
 ]
 
 
+# IPython resolves these lazily by name, so a module move silently disables the
+# formatter; tests/test_extension.py checks each path still resolves.
+_TASK_RESULT_TYPES: tuple[tuple[str, str], ...] = tuple(_TASK_RESULT_FORMATTERS)
+
+_TASK_RESULT_LIST_TYPE: tuple[str, str] = ("evo.compute.tasks.common.results", "TaskResultList")
+
+
 def _register_formatters(ipython: InteractiveShell) -> None:
     """Register HTML formatters for Evo SDK types.
 
@@ -167,16 +175,11 @@ def _register_formatters(ipython: InteractiveShell) -> None:
     )
 
     # Register formatters for compute task results
+    for (module_name, class_name), formatter in _TASK_RESULT_FORMATTERS.items():
+        html_formatter.for_type_by_name(module_name, class_name, formatter)
 
     html_formatter.for_type_by_name(
-        "evo.compute.tasks.kriging",
-        "KrigingResult",
-        format_task_result_with_target,
-    )
-
-    html_formatter.for_type_by_name(
-        "evo.compute.tasks.common.results",
-        "TaskResultList",
+        *_TASK_RESULT_LIST_TYPE,
         format_task_result_list,
     )
 

{evo_widgets-0.2.2 → evo_widgets-0.2.3}/src/evo/widgets/formatters.py

@@ -17,8 +17,9 @@ These formatters are registered with IPython when the extension is loaded.
 
 from __future__ import annotations
 
+from functools import partial
 from html import escape
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Callable
 
 from .html import (
     STYLESHEET,
@@ -422,12 +423,12 @@ def format_report_result(obj: Any) -> str:
 
     # Build the result table with alternating row colors
     headers = list(df.columns)
-    header_html = "".join([f"<th>{h}</th>" for h in headers])
+    header_html = "".join([f"<th>{escape(str(h))}</th>" for h in headers])
 
     rows_html = []
     for i, (_, row) in enumerate(df.iterrows()):
         row_class = 'class="alt-row"' if i % 2 == 1 else ""
-        cells = "".join([f"<td>{v if v is not None and v == v else ''}</td>" for v in row])
+        cells = "".join([f"<td>{escape(str(v)) if v is not None and v == v else ''}</td>" for v in row])
         rows_html.append(f"<tr {row_class}>{cells}</tr>")
 
     subtitle = f'<div class="subtitle">Created: {obj.created_at.strftime("%Y-%m-%d %H:%M:%S")} | Rows: {len(df)}</div>'
@@ -474,7 +475,8 @@ def format_report(obj: Any) -> str:
         for i, col in enumerate(obj._specification.columns):
             row_class = 'class="alt-row"' if i % 2 == 1 else ""
             col_rows.append(
-                f"<tr {row_class}><td>{col.label}</td><td>{col.aggregation}</td><td>{col.output_unit_id}</td></tr>"
+                f"<tr {row_class}><td>{escape(str(col.label))}</td><td>{escape(str(col.aggregation))}</td>"
+                f"<td>{escape(str(col.output_unit_id))}</td></tr>"
             )
         columns_html = f"""
         <div style="margin-top: 8px;"><strong>Columns:</strong></div>
@@ -490,8 +492,8 @@ def format_report(obj: Any) -> str:
         cat_rows = []
         for i, cat in enumerate(obj._specification.categories):
             row_class = 'class="alt-row"' if i % 2 == 1 else ""
-            values_str = ", ".join(cat.values) if cat.values else "(all)"
-            cat_rows.append(f"<tr {row_class}><td>{cat.label}</td><td>{values_str}</td></tr>")
+            values_str = ", ".join(str(v) for v in cat.values) if cat.values else "(all)"
+            cat_rows.append(f"<tr {row_class}><td>{escape(str(cat.label))}</td><td>{escape(values_str)}</td></tr>")
         categories_html = f"""
         <div style="margin-top: 8px;"><strong>Categories:</strong></div>
         <table class="nested">
@@ -672,73 +674,143 @@ def _get_schema_display(result: Any) -> str:
     return "Unknown"
 
 
-def _format_single_task_result_inner(result: Any, index: int | None = None) -> str:
-    """Render the inner HTML for a single task result card.
-
-    Returns the title, message, and detail table *without* the outer
-    ``<div class="evo">`` wrapper or the stylesheet so it can be embedded
-    inside both :func:`format_task_result_with_target` and
-    :func:`format_task_result_list`.
-
-    :param result: A result object (e.g. ``KrigingResult``).
-    :param index: Optional 1-based index to prefix the title with (e.g. ``#1``).
-    :return: HTML fragment.
-    """
+def _target_result_details(result: Any) -> tuple[list[tuple[str, str]], list[tuple[str, Any]], str | None]:
     portal_url = _get_task_result_portal_url(result)
-    links = [("Portal", portal_url)] if portal_url else None
+    links = [("Portal", portal_url)] if portal_url else []
+    rows: list[tuple[str, Any]] = []
+    target_name = getattr(result, "target_name", None)
+    if target_name is not None:
+        rows.extend([("Target:", target_name), ("Schema:", _get_schema_display(result))])
+        attribute_name = getattr(result, "attribute_name", None)
+        if attribute_name is not None:
+            rows.append(("Attribute:", markup(f'<span class="attr-highlight">{escape(attribute_name)}</span>')))
+    return links, rows, getattr(result, "message", None)
+
+
+def _turning_bands_result_details(result: Any) -> tuple[list[tuple[str, str]], list[tuple[str, Any]], str | None]:
+    links, rows, message = _target_result_details(result)
+    if result.simulations_attribute is not None:
+        rows.append(("Simulations:", result.simulations_attribute.name))
+    return links, rows, message
+
+
+def _conditional_simulation_result_details(
+    result: Any,
+) -> tuple[list[tuple[str, str]], list[tuple[str, Any]], str | None]:
+    links, rows, message = _target_result_details(result)
+    if result.dashboard_url:
+        links.append(("Dashboard", result.dashboard_url))
+    rows.extend(
+        [
+            ("Mean attribute:", result.summary_attributes.mean.name),
+            ("Variance attribute:", result.summary_attributes.variance.name),
+        ]
+    )
+    if result.validation_summary is not None:
+        rows.extend(
+            [
+                ("Reference mean:", result.validation_summary.reference_mean),
+                ("Simulated mean:", result.validation_summary.mean),
+            ]
+        )
+    return links, rows, message
 
-    result_type = getattr(result, "TASK_DISPLAY_NAME", "Task")
 
-    if index is not None:
-        title = f"#{index} ✓ {result_type} Result"
-    else:
-        title = f"✓ {result_type} Result"
+def _location_wise_result_details(result: Any) -> tuple[list[tuple[str, str]], list[tuple[str, Any]], str | None]:
+    links, rows, message = _target_result_details(result)
+    if result.attribute_names:
+        rows.append(("Attributes:", ", ".join(result.attribute_names)))
+    return links, rows, message
 
-    target_name = getattr(result, "target_name", None)
-    if target_name is not None:
-        schema_display = _get_schema_display(result)
-        attribute_name = getattr(result, "attribute_name", "")
+
+def _distribution_result_details(result: Any) -> tuple[list[tuple[str, str]], list[tuple[str, Any]], str | None]:
+    try:
+        portal_url = get_portal_url_from_reference(result.distribution_reference)
+    except ValueError:
+        portal_url = None
+    links = [("Portal", portal_url)] if portal_url else []
+    rows = [("Distribution:", result.distribution_name), ("Schema:", _get_schema_display(result))]
+    return links, rows, result.message
+
+
+def _simulation_report_result_details(result: Any) -> tuple[list[tuple[str, str]], list[tuple[str, Any]], str | None]:
+    links = []
+    if result.report_reference:
+        links.append(("Report", result.report_reference))
+    if result.dashboard_url:
+        links.append(("Dashboard", result.dashboard_url))
+    rows = []
+    if result.validation_summary is not None:
         rows = [
-            ("Target:", target_name),
-            ("Schema:", schema_display),
-            ("Attribute:", markup(f'<span class="attr-highlight">{escape(attribute_name)}</span>')),
+            ("Reference mean:", result.validation_summary.reference_mean),
+            ("Simulated mean:", result.validation_summary.mean),
         ]
-    else:
-        rows = []
-
-    table_rows = [build_table_row(label, value) for label, value in rows]
+    return links, rows, None
+
+
+_TASK_RESULT_DETAILS: dict[tuple[str, str], Callable[..., tuple[list, list, str | None]]] = {
+    (f"evo.compute.tasks.geostatistics.{module}", class_name): details
+    for module, class_name, details in (
+        ("break_ties", "BreakTiesResult", _target_result_details),
+        ("conditional_turning_bands", "ConditionalTurningBandsResult", _turning_bands_result_details),
+        ("conditioned_simulator", "ConSimResult", _conditional_simulation_result_details),
+        ("continuous_distribution", "ContinuousDistributionResult", _distribution_result_details),
+        ("declustering", "DeclusteringResult", _target_result_details),
+        ("idw", "IDWResult", _target_result_details),
+        ("knn", "KNNResult", _target_result_details),
+        ("kriging", "KrigingResult", _target_result_details),
+        ("location_wise", "LocationWiseResult", _location_wise_result_details),
+        ("loss_calculation", "LossCalculationResult", _target_result_details),
+        ("normal_score", "NormalScoreResult", _target_result_details),
+        ("profit_calculation", "ProfitCalculationResult", _target_result_details),
+        ("simulation_report", "SimulationReportResult", _simulation_report_result_details),
+    )
+}
 
-    html = build_title(title, links)
-    message = getattr(result, "message", None)
-    if message:
-        html += f'<div class="message">{message}</div>'
-    if table_rows:
-        html += f"<table>{''.join(table_rows)}</table>"
 
+def _format_single_task_result_inner(result: Any, index: int | None = None, details: Callable | None = None) -> str:
+    """Render a result fragment, including its result-specific links and rows."""
+    result_type = getattr(result, "TASK_DISPLAY_NAME", "Task")
+    title = f"#{index} ✓ {result_type} Result" if index is not None else f"✓ {result_type} Result"
+    if details is None:
+        for result_class in type(result).__mro__:
+            details = _TASK_RESULT_DETAILS.get((result_class.__module__, result_class.__name__))
+            if details is not None:
+                break
+        else:
+            details = _target_result_details
+    links, rows, message = details(result)
+    html = build_title(title, links or None)
+    html += f'<div class="message">{escape(str(message)) if message else "Task completed"}</div>'
+    if rows:
+        html += f"<table>{''.join(build_table_row(label, value) for label, value in rows)}</table>"
     return html
 
 
+def _format_task_result(result: Any, details: Callable | None = None) -> str:
+    return STYLESHEET + '<div class="evo">' + _format_single_task_result_inner(result, details=details) + "</div>"
+
+
+_TASK_RESULT_FORMATTERS = {
+    result_type: partial(_format_task_result, details=details) for result_type, details in _TASK_RESULT_DETAILS.items()
+}
+
+
 def format_task_result_with_target(result: Any) -> str:
-    """Format a KrigingResult or any other task result with a target as HTML.
+    """Format a compute task result as HTML, using its result-specific fields.
 
-    Displays the task completion status, target information, and Portal links.
+    Displays the task completion status, available details, and related links.
 
-    :param result: A KrigingResult object with message, target_name, schema,
-        attribute_name, and _target attributes.
+    :param result: A geostatistics task result.
     :return: HTML string for the task result.
     """
-    html = STYLESHEET
-    html += '<div class="evo">'
-    html += _format_single_task_result_inner(result)
-    html += "</div>"
-    return html
+    return _format_task_result(result)
 
 
 def format_task_result_list(results: Any) -> str:
     """Format a TaskResultList as styled HTML.
 
-    Renders each result as an individually-formatted card (reusing the
-    same layout as :func:`format_task_result_with_target`) wrapped in a
+    Renders each result with its own shape-specific details, wrapped in a
     single container with a summary title.
 
     :param results: A ``TaskResultList`` object with iterable result items.

{evo_widgets-0.2.2 → evo_widgets-0.2.3}/src/evo/widgets/html.py

@@ -14,6 +14,7 @@
 from collections.abc import Sequence
 from html import escape
 from pathlib import Path
+from urllib.parse import urlsplit
 
 # Load CSS from external file
 _CSS_PATH = Path(__file__).parent / "assets" / "styles.css"
@@ -53,8 +54,19 @@ def build_title(text: str, links: list[tuple[str, str]] | None = None) -> str:
     :param links: Optional list of (label, url) tuples for links next to the title.
     :return: HTML string.
     """
-    if links:
-        link_html = " | ".join([f'<a href="{escape(url)}" target="_blank">{escape(label)}</a>' for label, url in links])
+    safe_links = []
+    for label, url in links or []:
+        try:
+            parsed = urlsplit(url)
+            if parsed.scheme not in ("http", "https") or not parsed.hostname or any(ord(char) <= 32 for char in url):
+                continue
+        except ValueError:
+            continue
+        safe_links.append((label, url))
+    if safe_links:
+        link_html = " | ".join(
+            f'<a href="{escape(url)}" target="_blank">{escape(label)}</a>' for label, url in safe_links
+        )
         return f'<div class="title"><span>{escape(text)}</span><span class="title-links">{link_html}</span></div>'
     return f'<div class="title">{escape(text)}</div>'