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

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: evo-widgets
-Version: 0.2.1
+Version: 0.2.2
 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.1 → evo_widgets-0.2.2}/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.1"
+version = "0.2.2"
 requires-python = ">=3.10"
 license-files = ["LICENSE.md"]
 dynamic = ["readme"]

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

@@ -17,6 +17,7 @@ These formatters are registered with IPython when the extension is loaded.
 
 from __future__ import annotations
 
+from html import escape
 from typing import TYPE_CHECKING, Any
 
 from .html import (
@@ -25,6 +26,7 @@ from .html import (
     build_table_row,
     build_table_row_vtop,
     build_title,
+    markup,
 )
 from .urls import (
     get_blocksync_block_model_url_from_environment,
@@ -103,9 +105,9 @@ def _format_bounding_box(bbox: dict[str, Any]) -> str:
     :return: HTML string for the bounding box table.
     """
     bbox_rows = [
-        ["<strong>X:</strong>", f"{bbox.get('min_x', 0):.2f}", f"{bbox.get('max_x', 0):.2f}"],
-        ["<strong>Y:</strong>", f"{bbox.get('min_y', 0):.2f}", f"{bbox.get('max_y', 0):.2f}"],
-        ["<strong>Z:</strong>", f"{bbox.get('min_z', 0):.2f}", f"{bbox.get('max_z', 0):.2f}"],
+        [markup("<strong>X:</strong>"), f"{bbox.get('min_x', 0):.2f}", f"{bbox.get('max_x', 0):.2f}"],
+        [markup("<strong>Y:</strong>"), f"{bbox.get('min_y', 0):.2f}", f"{bbox.get('max_y', 0):.2f}"],
+        [markup("<strong>Z:</strong>"), f"{bbox.get('min_z', 0):.2f}", f"{bbox.get('max_z', 0):.2f}"],
     ]
     return build_nested_table(["", "Min", "Max"], bbox_rows)
 
@@ -154,7 +156,7 @@ def _build_html_from_rows(
     return html
 
 
-def _format_attributes_spec(attributes, rows) -> str:
+def _format_attributes_spec(attributes) -> str:
     attr_rows = []
     for attr in attributes:
         attr_info = attr.as_dict()
@@ -167,12 +169,19 @@ def _format_attributes_spec(attributes, rows) -> str:
 
 def _format_all_attribute_specs(obj, rows) -> None:
     # Build datasets section - add as rows to the main table
+    top_level_attrs = None
+    if hasattr(obj, "attributes") and len(obj.attributes) > 0:
+        top_level_attrs = obj.attributes
+        rows.append(("Attributes:", _format_attributes_spec(obj.attributes)))
+
     sub_models = getattr(obj, "_sub_models", [])
     for dataset_name in sub_models:
         dataset = getattr(obj, dataset_name, None)
         if dataset and hasattr(dataset, "attributes") and len(dataset.attributes) > 0:
-            # Build attribute rows
-            rows.append((f"{dataset_name}", _format_attributes_spec(dataset.attributes, rows)))
+            # Skip sub-model attributes that are an alias for the already-rendered top-level attributes
+            if dataset.attributes is top_level_attrs:
+                continue
+            rows.append((f"{dataset_name} attributes:", _format_attributes_spec(dataset.attributes)))
 
 
 def format_base_object(obj: Any) -> str:
@@ -321,7 +330,7 @@ def _format_downhole_collection_collections(obj, rows):
         if collection.collection_type == "distance":
             rows.append((f"{name} distance unit:", collection.distance.unit))
             if attributes := collection.distance.attributes:
-                rows.append({f"{name} attributes:", _format_attributes_spec(attributes, rows)})
+                rows.append((f"{name} attributes:", _format_attributes_spec(attributes)))
 
 
 def format_downhole_collection(obj: DownholeCollection) -> str:
@@ -345,7 +354,6 @@ def format_downhole_collection(obj: DownholeCollection) -> str:
     rows.append(("Number of holes:", str(obj.location.hole_id.length)))
 
     _format_all_attribute_specs(obj, rows)
-    _format_all_attribute_specs(obj.location, rows)
     _format_downhole_collection_collections(obj, rows)
 
     return _build_html_from_rows(name, title_links, rows)
@@ -571,17 +579,17 @@ def format_block_model(obj: Any) -> str:
     # Add geometry info
     geom = obj.geometry
     geom_rows = [
-        ["<strong>Origin:</strong>", f"({geom.origin.x:.2f}, {geom.origin.y:.2f}, {geom.origin.z:.2f})"],
-        ["<strong>N Blocks:</strong>", f"({geom.n_blocks.nx}, {geom.n_blocks.ny}, {geom.n_blocks.nz})"],
+        [markup("<strong>Origin:</strong>"), f"({geom.origin.x:.2f}, {geom.origin.y:.2f}, {geom.origin.z:.2f})"],
+        [markup("<strong>N Blocks:</strong>"), f"({geom.n_blocks.nx}, {geom.n_blocks.ny}, {geom.n_blocks.nz})"],
         [
-            "<strong>Block Size:</strong>",
+            markup("<strong>Block Size:</strong>"),
             f"({geom.block_size.dx:.2f}, {geom.block_size.dy:.2f}, {geom.block_size.dz:.2f})",
         ],
     ]
     if geom.rotation:
         geom_rows.append(
             [
-                "<strong>Rotation:</strong>",
+                markup("<strong>Rotation:</strong>"),
                 f"({geom.rotation.dip_azimuth:.2f}, {geom.rotation.dip:.2f}, {geom.rotation.pitch:.2f})",
             ]
         )
@@ -693,7 +701,7 @@ def _format_single_task_result_inner(result: Any, index: int | None = None) -> s
         rows = [
             ("Target:", target_name),
             ("Schema:", schema_display),
-            ("Attribute:", f'<span class="attr-highlight">{attribute_name}</span>'),
+            ("Attribute:", markup(f'<span class="attr-highlight">{escape(attribute_name)}</span>')),
         ]
     else:
         rows = []

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

@@ -11,6 +11,8 @@
 
 """Shared HTML styles for Jupyter notebook representations across all Evo SDK packages."""
 
+from collections.abc import Sequence
+from html import escape
 from pathlib import Path
 
 # Load CSS from external file
@@ -21,14 +23,27 @@ _CSS_CONTENT = _CSS_PATH.read_text(encoding="utf-8")
 STYLESHEET = f"<style>\n{_CSS_CONTENT}</style>\n"
 
 
-def build_container(content: str, css_class: str = "evo") -> str:
+class HtmlMarkup(str):
+    """Markup deliberately produced by this package and safe to embed in HTML."""
+
+
+def markup(value: str) -> HtmlMarkup:
+    """Mark package-generated HTML for explicit insertion by the HTML builders."""
+    return HtmlMarkup(value)
+
+
+def _html_text(value: object) -> str:
+    return str(value) if isinstance(value, HtmlMarkup) else escape(str(value))
+
+
+def build_container(content: str | HtmlMarkup, css_class: str = "evo") -> str:
     """Wrap content in a styled container div.
 
-    :param content: HTML content to wrap.
+    :param content: Content to wrap, escaped unless wrapped with :func:`markup`.
     :param css_class: CSS class for the container (default: "evo").
     :return: Wrapped HTML string.
     """
-    return f'{STYLESHEET}<div class="{css_class}">{content}</div>'
+    return f'{STYLESHEET}<div class="{escape(css_class)}">{_html_text(content)}</div>'
 
 
 def build_title(text: str, links: list[tuple[str, str]] | None = None) -> str:
@@ -39,31 +54,31 @@ def build_title(text: str, links: list[tuple[str, str]] | None = None) -> str:
     :return: HTML string.
     """
     if links:
-        link_html = " | ".join([f'<a href="{url}" target="_blank">{label}</a>' for label, url in links])
-        return f'<div class="title"><span>{text}</span><span class="title-links">{link_html}</span></div>'
-    return f'<div class="title">{text}</div>'
+        link_html = " | ".join([f'<a href="{escape(url)}" target="_blank">{escape(label)}</a>' for label, url in 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>'
 
 
-def build_table_row(label: str, value: str, is_last: bool = False) -> str:
+def build_table_row(label: str, value: str | HtmlMarkup, is_last: bool = False) -> str:
     """Create a table row with label and value.
 
     :param label: Label text.
-    :param value: Value text (can contain HTML).
-    :param is_last: If True, don't add bottom border.
+    :param value: Value text, escaped unless wrapped with :func:`markup`.
+    :param is_last: Retained for backwards compatibility; has no effect.
     :return: HTML string.
     """
-    return f'<tr><td class="label">{label}</td><td class="value">{value}</td></tr>'
+    return f'<tr><td class="label">{_html_text(label)}</td><td class="value">{_html_text(value)}</td></tr>'
 
 
-def build_table_row_vtop(label: str, value: str, is_last: bool = False) -> str:
+def build_table_row_vtop(label: str, value: str | HtmlMarkup, is_last: bool = False) -> str:
     """Create a table row with label and value (label top-aligned).
 
     :param label: Label text.
-    :param value: Value text (can contain HTML).
-    :param is_last: If True, don't add bottom border.
+    :param value: Value text, escaped unless wrapped with :func:`markup`.
+    :param is_last: Retained for backwards compatibility; has no effect.
     :return: HTML string.
     """
-    return f'<tr><td class="label-vtop">{label}</td><td class="value">{value}</td></tr>'
+    return f'<tr><td class="label-vtop">{_html_text(label)}</td><td class="value">{_html_text(value)}</td></tr>'
 
 
 def build_section_divider(title: str) -> str:
@@ -72,10 +87,10 @@ def build_section_divider(title: str) -> str:
     :param title: Section title.
     :return: HTML string.
     """
-    return f'<div class="section"><div class="section-heading">{title}</div>'
+    return f'<div class="section"><div class="section-heading">{_html_text(title)}</div>'
 
 
-def build_table(rows: list[tuple[str, str]]) -> str:
+def build_table(rows: list[tuple[str, str | HtmlMarkup]]) -> str:
     """Build an HTML table from rows of (label, value) tuples.
 
     :param rows: List of (label, value) tuples.
@@ -85,7 +100,9 @@ def build_table(rows: list[tuple[str, str]]) -> str:
     return f"<table>{''.join(table_rows)}</table>"
 
 
-def build_nested_table(headers: list[str], rows: list[list[str]], css_class: str = "") -> str:
+def build_nested_table(
+    headers: Sequence[str], rows: Sequence[Sequence[str | int | float]], css_class: str = ""
+) -> HtmlMarkup:
     """Build a nested HTML table with headers and data rows.
 
     :param headers: List of header strings.
@@ -93,12 +110,12 @@ def build_nested_table(headers: list[str], rows: list[list[str]], css_class: str
     :param css_class: Additional CSS classes to add to the table (optional).
     :return: HTML string for a nested table.
     """
-    class_attr = f' class="nested {css_class}"' if css_class else ' class="nested"'
+    class_attr = f' class="nested {escape(css_class)}"' if css_class else ' class="nested"'
 
     # Build header row
     header_cells = []
     for i, header in enumerate(headers):
-        header_cells.append(f"<th>{header}</th>")
+        header_cells.append(f"<th>{_html_text(header)}</th>")
 
     # Build data rows
     data_rows = []
@@ -109,20 +126,31 @@ def build_nested_table(headers: list[str], rows: list[list[str]], css_class: str
             if isinstance(cell, (int, float)):
                 formatted_cell = f"{cell:.2f}"
             else:
-                formatted_cell = str(cell)
+                formatted_cell = _html_text(cell)
             cells.append(f"<td>{formatted_cell}</td>")
         data_rows.append(f"<tr>{''.join(cells)}</tr>")
 
-    return f"<table{class_attr}><tr>{''.join(header_cells)}</tr>{''.join(data_rows)}</table>"
+    return markup(f"<table{class_attr}><tr>{''.join(header_cells)}</tr>{''.join(data_rows)}</table>")
 
 
-def build_object_html(title: str, rows: list[tuple[str, str]], extra_content: str = "") -> str:
+def build_object_html(
+    title: str,
+    rows: list[tuple[str, str | HtmlMarkup]],
+    extra_content: str | HtmlMarkup = "",
+) -> str:
     """Build a complete object HTML representation.
 
     :param title: Object title/name.
     :param rows: List of (label, value) tuples for the main properties table.
-    :param extra_content: Additional HTML content to append after the table (optional).
+    :param extra_content: Additional content, escaped unless wrapped with :func:`markup`.
     :return: Complete HTML string with stylesheet.
     """
-    html_parts = [STYLESHEET, '<div class="evo">', build_title(title), build_table(rows), extra_content, "</div>"]
+    html_parts = [
+        STYLESHEET,
+        '<div class="evo">',
+        build_title(title),
+        build_table(rows),
+        _html_text(extra_content),
+        "</div>",
+    ]
     return "".join(html_parts)

{evo_widgets-0.2.1 → evo_widgets-0.2.2}/src/evo/widgets/urls.py

@@ -17,7 +17,7 @@ This module provides functions to generate URLs for viewing objects in the Evo P
 from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
-from urllib.parse import urlparse
+from urllib.parse import urlencode, urlparse
 from uuid import UUID
 
 from evo.objects import ObjectReference
@@ -121,7 +121,7 @@ def get_blocksync_report_url(
     base_url = get_blocksync_base_url("")
     url = f"{base_url}/{org_id}/{hub_code}/{workspace_id}/blockmodel/{block_model_id}/reports/{report_id}"
     if result_id:
-        url += f"?result_id={result_id}"
+        url += f"?{urlencode({'result_id': result_id})}"
     return url