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

{evo_widgets-0.2.0 → 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.0
+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
@@ -9,7 +9,7 @@ Project-URL: Documentation, https://developer.seequent.com/
 Author-email: Seequent <support@seequent.com>
 License-File: LICENSE.md
 Requires-Python: >=3.10
-Requires-Dist: evo-sdk-common>=0.5.8
+Requires-Dist: evo-sdk-common>=0.5.25
 Requires-Dist: ipython>=7.0.0
 Description-Content-Type: text/markdown
 

{evo_widgets-0.2.0 → 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.0"
+version = "0.2.2"
 requires-python = ">=3.10"
 license-files = ["LICENSE.md"]
 dynamic = ["readme"]
@@ -10,7 +10,7 @@ authors = [
 ]
 
 dependencies = [
-    "evo-sdk-common>=0.5.8",
+    "evo-sdk-common>=0.5.25",
     "ipython>=7.0.0",
 ]
 
@@ -29,7 +29,7 @@ test = [
 dev = [
     "bumpver",
     "coverage[toml]",
-    "ruff==0.14.0",
+    "ruff==0.15.16",
     {include-group="test"},
 ]
 

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

@@ -1,4 +1,4 @@
-#  Copyright © 2025 Bentley Systems, Incorporated
+#  Copyright © 2026 Bentley Systems, Incorporated
 #  Licensed under the Apache License, Version 2.0 (the "License");
 #  you may not use this file except in compliance with the License.
 #  You may obtain a copy of the License at
@@ -39,6 +39,7 @@ from .formatters import (
     format_block_model,
     format_block_model_attributes,
     format_block_model_version,
+    format_downhole_collection,
     format_report,
     format_report_result,
     format_task_result_list,
@@ -159,6 +160,12 @@ def _register_formatters(ipython: InteractiveShell) -> None:
         format_block_model_attributes,
     )
 
+    html_formatter.for_type_by_name(
+        "evo.objects.typed.downhole_collection",
+        "DownholeCollection",
+        format_downhole_collection,
+    )
+
     # Register formatters for compute task results
 
     html_formatter.for_type_by_name(

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

@@ -1,4 +1,4 @@
-#  Copyright © 2025 Bentley Systems, Incorporated
+#  Copyright © 2026 Bentley Systems, Incorporated
 #  Licensed under the Apache License, Version 2.0 (the "License");
 #  you may not use this file except in compliance with the License.
 #  You may obtain a copy of the License at
@@ -17,7 +17,8 @@ These formatters are registered with IPython when the extension is loaded.
 
 from __future__ import annotations
 
-from typing import Any
+from html import escape
+from typing import TYPE_CHECKING, Any
 
 from .html import (
     STYLESHEET,
@@ -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,
@@ -33,12 +35,17 @@ from .urls import (
     get_viewer_url_for_object,
 )
 
+if TYPE_CHECKING:
+    from evo.objects.typed import DownholeCollection
+
+
 __all__ = [
     "format_attributes_collection",
     "format_base_object",
     "format_block_model",
     "format_block_model_attributes",
     "format_block_model_version",
+    "format_downhole_collection",
     "format_report",
     "format_report_result",
     "format_task_result_list",
@@ -98,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)
 
@@ -149,6 +156,34 @@ def _build_html_from_rows(
     return html
 
 
+def _format_attributes_spec(attributes) -> str:
+    attr_rows = []
+    for attr in attributes:
+        attr_info = attr.as_dict()
+        attr_name = attr_info.get("name", "Unknown")
+        attr_type = attr_info.get("attribute_type", "Unknown")
+        attr_rows.append([attr_name, attr_type])
+
+    return build_nested_table(["Attribute", "Type"], attr_rows)
+
+
+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:
+            # 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:
     """Format a BaseObject (or subclass) as HTML.
 
@@ -169,21 +204,7 @@ def format_base_object(obj: Any) -> str:
     if crs := doc.get("coordinate_reference_system"):
         rows.append(("CRS:", _format_crs(crs)))
 
-    # Build datasets section - add as rows to the main table
-    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
-            attr_rows = []
-            for attr in dataset.attributes:
-                attr_info = attr.as_dict()
-                attr_name = attr_info.get("name", "Unknown")
-                attr_type = attr_info.get("attribute_type", "Unknown")
-                attr_rows.append([attr_name, attr_type])
-
-            attrs_table = build_nested_table(["Attribute", "Type"], attr_rows)
-            rows.append((f"{dataset_name}:", attrs_table))
+    _format_all_attribute_specs(obj, rows)
 
     return _build_html_from_rows(name, title_links, rows)
 
@@ -301,6 +322,43 @@ def format_variogram(obj: Any) -> str:
     return _build_html_from_rows(name, title_links, rows, extra_content)
 
 
+def _format_downhole_collection_collections(obj, rows):
+    for i, collection in enumerate(obj.collections):
+        name = f"Collection {i + 1}"
+        rows.append((f"{name} name:", collection.name))
+        rows.append((f"{name} type:", collection.collection_type))
+        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)))
+
+
+def format_downhole_collection(obj: DownholeCollection) -> str:
+    """Format a DownholeCollection object as HTML.
+
+    This formatter renders a downhole collection by extracting metadata and rendering it as a styled HTML table with
+    Portal/Viewer links.
+
+    :param obj: A DownholeCollection object from evo.objects.typed.downhole_collection.
+    :return: HTML string representation.
+    """
+    doc = obj.as_dict()
+    name, title_links, rows = _get_base_metadata(obj)
+    rows.append(("Bounding box:", _format_bounding_box(doc["bounding_box"])))
+    rows.append(("CRS:", _format_crs(doc["coordinate_reference_system"])))
+
+    # DownholeCollection-specific scalar properties
+    rows.append(("Distance unit:", str(obj.distance_unit)))
+    rows.append(("Desurvey method:", str(obj.desurvey)))
+    rows.append(("Type:", obj.type))
+    rows.append(("Number of holes:", str(obj.location.hole_id.length)))
+
+    _format_all_attribute_specs(obj, rows)
+    _format_downhole_collection_collections(obj, rows)
+
+    return _build_html_from_rows(name, title_links, rows)
+
+
 def format_block_model_version(obj: Any) -> str:
     """Format a block model Version object as HTML.
 
@@ -521,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})",
             ]
         )
@@ -643,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.0 → 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.0 → 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