feat(short-id): implement clickable short ID links in object titles

Author: PierreRaybaut

datalab/gui/objectview.py

@@ -46,8 +46,14 @@
 from sigima.objects import ImageObj, SignalObj
 
 from datalab.config import _
-from datalab.objectmodel import ObjectGroup, get_short_id, get_uuid
+from datalab.objectmodel import (
+    ObjectGroup,
+    find_short_ids_in_title,
+    get_short_id,
+    get_uuid,
+)
 from datalab.utils.qthelpers import block_signals
+from datalab.widgets.titledelegate import ClickableTitleDelegate
 
 if TYPE_CHECKING:
     from typing import Any
@@ -97,6 +103,9 @@ def __init__(self, parent: QW.QWidget, objmodel: ObjectModel) -> None:
         self.itemDoubleClicked.connect(self.item_double_clicked)
         self.header().setSectionResizeMode(QW.QHeaderView.Interactive)
         self.itemChanged.connect(lambda item: self.resizeColumnToContents(0))
+        self._title_delegate = ClickableTitleDelegate(self)
+        self.setItemDelegateForColumn(0, self._title_delegate)
+        self.viewport().setMouseTracking(True)
 
     def __str__(self) -> str:
         """Return string representation"""
@@ -201,16 +210,114 @@ def get_sel_groups(self) -> list[ObjectGroup]:
         """Return selected groups"""
         return self.objmodel.get_groups(self.get_sel_group_uuids())
 
-    @staticmethod
+    def _resolve_short_id(
+        self, short_id: str
+    ) -> tuple[str, SignalObj | ImageObj | ObjectGroup] | None:
+        """Resolve a short ID embedded in a title to ``(panel_str, obj)``.
+
+        Default implementation only looks up the tree's own model and returns
+        an empty ``panel_str``. Subclasses with access to several panels
+        should override this method.
+        """
+        obj = self.objmodel.find_by_short_id(short_id)
+        if obj is None:
+            return None
+        return ("", obj)
+
+    def _build_short_id_tooltip(self, text: str) -> str:
+        """Return an HTML tooltip fragment listing the source objects
+        referenced by short IDs embedded in ``text``, or an empty string when
+        no such reference is found."""
+        matches = find_short_ids_in_title(text)
+        rows: list[str] = []
+        seen: set[str] = set()
+        for idx, (start, _end, sid) in enumerate(matches):
+            if idx == 0 and start == 0:
+                # Skip the leading "<short_id>:" prefix
+                continue
+            if sid in seen:
+                continue
+            seen.add(sid)
+            resolved = self._resolve_short_id(sid)
+            if resolved is None:
+                continue
+            panel_str, obj = resolved
+            kind = (
+                _("group")
+                if isinstance(obj, ObjectGroup)
+                else _("signal")
+                if isinstance(obj, SignalObj)
+                else _("image")
+            )
+            suffix = f" \u00b7 {panel_str}" if panel_str else ""
+            rows.append(f"<b>{sid}</b> \u2192 {obj.title} <i>({kind}{suffix})</i>")
+        if not rows:
+            return ""
+        title = _("Source objects")
+        return (
+            f"<p style='white-space:pre'><i><u>{title}:</u></i><br>"
+            f"{'<br>'.join(rows)}</p>"
+        )
+
     def __update_item(
-        item: QW.QTreeWidgetItem, obj: SignalObj | ImageObj | ObjectGroup
+        self, item: QW.QTreeWidgetItem, obj: SignalObj | ImageObj | ObjectGroup
     ) -> None:
         """Update item"""
-        item.setText(0, f"{get_short_id(obj)}: {obj.title}")
+        text = f"{get_short_id(obj)}: {obj.title}"
+        item.setText(0, text)
+        tooltip_parts: list[str] = []
+        sid_tooltip = self._build_short_id_tooltip(text)
+        if sid_tooltip:
+            tooltip_parts.append(sid_tooltip)
         if isinstance(obj, (SignalObj, ImageObj)):
-            item.setToolTip(0, metadata_to_html(obj.metadata))
+            meta_tooltip = metadata_to_html(obj.metadata)
+            if meta_tooltip:
+                tooltip_parts.append(meta_tooltip)
+        item.setToolTip(0, "".join(tooltip_parts))
         item.setData(0, QC.Qt.UserRole, get_uuid(obj))
 
+    def _handle_short_id_click(self, short_id: str) -> None:
+        """Handle a click on a short-ID hyperlink. Default implementation
+        selects the matching object within the tree's own model."""
+        resolved = self._resolve_short_id(short_id)
+        if resolved is None:
+            return
+        _panel_str, obj = resolved
+        self.set_current_item_id(get_uuid(obj))
+
+    def _short_id_at(self, pos: QC.QPoint) -> str | None:
+        """Return the short ID under viewport position ``pos``, or ``None``
+        when the cursor is not over an anchor."""
+        index = self.indexAt(pos)
+        if not index.isValid() or index.column() != 0:
+            return None
+        rect = self.visualRect(index)
+        option = self.viewOptions()
+        option.rect = rect
+        return self._title_delegate.anchor_at(index, rect, pos, option)
+
+    # pylint: disable=invalid-name
+    def mousePressEvent(self, event: QG.QMouseEvent) -> None:
+        """Reimplement Qt method to handle short-ID hyperlink clicks."""
+        if event.button() == QC.Qt.LeftButton:
+            short_id = self._short_id_at(event.pos())
+            if short_id is not None:
+                event.accept()
+                self._handle_short_id_click(short_id)
+                return
+        super().mousePressEvent(event)
+
+    # pylint: disable=invalid-name
+    def mouseMoveEvent(self, event: QG.QMouseEvent) -> None:
+        """Reimplement Qt method to update the cursor over short-ID anchors."""
+        short_id = self._short_id_at(event.pos())
+        viewport = self.viewport()
+        if short_id is not None:
+            viewport.setCursor(QC.Qt.PointingHandCursor)
+        else:
+            viewport.unsetCursor()
+        super().mouseMoveEvent(event)
+
     def populate_tree(self) -> None:
         """Populate tree with objects"""
         uuid = self.get_current_item_id()
@@ -387,6 +494,48 @@ def __init__(self, parent: BaseDataPanel, objmodel: ObjectModel) -> None:
         self.__dragged_groups: list[QW.QListWidgetItem] = []
         self.__dragged_expanded_states: dict[QW.QListWidgetItem, bool] = {}
 
+    def _resolve_short_id(
+        self, short_id: str
+    ) -> tuple[str, SignalObj | ImageObj | ObjectGroup] | None:
+        """Resolve a short ID across the signal *and* image panels of the main
+        window, so titles can reference objects living in either panel.
+        """
+        panel: BaseDataPanel = self.parent()
+        mainwindow = getattr(panel, "mainwindow", None)
+        candidates: list[tuple[str, ObjectModel]] = []
+        if mainwindow is not None:
+            sigpanel = getattr(mainwindow, "signalpanel", None)
+            if sigpanel is not None:
+                candidates.append(("signal", sigpanel.objmodel))
+            imgpanel = getattr(mainwindow, "imagepanel", None)
+            if imgpanel is not None:
+                candidates.append(("image", imgpanel.objmodel))
+        else:
+            candidates.append((panel.PANEL_STR_ID, self.objmodel))
+        # Prefer the panel that owns this view (so a self-reference resolves
+        # locally), then fall back to the other panel.
+        own = panel.PANEL_STR_ID
+        candidates.sort(key=lambda c: 0 if c[0] == own else 1)
+        for panel_str, model in candidates:
+            obj = model.find_by_short_id(short_id)
+            if obj is not None:
+                return (panel_str, obj)
+        return None
+
+    def _handle_short_id_click(self, short_id: str) -> None:
+        """Select the referenced object, switching active panel if needed."""
+        resolved = self._resolve_short_id(short_id)
+        if resolved is None:
+            return
+        panel_str, obj = resolved
+        panel: BaseDataPanel = self.parent()
+        mainwindow = getattr(panel, "mainwindow", None)
+        if mainwindow is not None and panel_str and panel_str != panel.PANEL_STR_ID:
+            mainwindow.set_current_panel(panel_str)
+            mainwindow.select_objects([get_uuid(obj)], panel=panel_str)
+        else:
+            self.set_current_item_id(get_uuid(obj))
+
     def paintEvent(self, event):  # pylint: disable=C0103
         """Reimplement Qt method"""
         super().paintEvent(event)

datalab/objectmodel.py

@@ -110,6 +110,24 @@ def patch_title_with_ids(
         ) from exc
 
 
+#: Regex matching short IDs as embedded in computation titles
+#: (e.g. ``s001``, ``i012``, ``gs003``, ``gi007``).
+SHORT_ID_REGEX = re.compile(r"\b(g?[si])(\d{3})\b")
+
+
+def find_short_ids_in_title(title: str) -> list[tuple[int, int, str]]:
+    """Return a list of ``(start, end, short_id)`` tuples for every short ID
+    occurrence found in ``title``.
+
+    Args:
+        title: title string to scan
+
+    Returns:
+        List of ``(start, end, short_id)`` tuples, sorted by ``start``.
+    """
+    return [(m.start(), m.end(), m.group(0)) for m in SHORT_ID_REGEX.finditer(title)]
+
+
 class ObjectGroup:
     """Represents a DataLab object group
 
@@ -292,6 +310,28 @@ def get_object_or_group(self, uuid: str) -> SignalObj | ImageObj | ObjectGroup:
                 return group
         raise KeyError(f"Object or group with uuid {uuid} not found")
 
+    def find_by_short_id(
+        self, short_id: str
+    ) -> SignalObj | ImageObj | ObjectGroup | None:
+        """Return the object or group whose short ID matches ``short_id``,
+        or ``None`` if no match is found in this model.
+
+        Args:
+            short_id: short ID to look up (e.g. ``"s001"``, ``"i012"``,
+             ``"gs003"`` or ``"gi007"``).
+
+        Returns:
+            The matching :class:`sigima.SignalObj`, :class:`sigima.ImageObj`
+            or :class:`ObjectGroup` instance, or ``None``.
+        """
+        for group in self._groups:
+            if get_short_id(group) == short_id:
+                return group
+        for obj in self._objects.values():
+            if get_short_id(obj) == short_id:
+                return obj
+        return None
+
     def get_group(self, uuid: str) -> ObjectGroup:
         """Return group with uuid"""
         for group in self._groups:

datalab/tests/features/common/title_short_id_unit_test.py

@@ -0,0 +1,62 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Short ID title link unit test.
+
+Validates the helpers underpinning the clickable short-ID feature in
+:mod:`datalab.gui.objectview`:
+
+- :func:`datalab.objectmodel.find_short_ids_in_title`
+- :func:`datalab.widgets.titledelegate._build_html`
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+
+from __future__ import annotations
+
+from datalab.objectmodel import find_short_ids_in_title
+from datalab.widgets.titledelegate import SHORT_ID_URL_SCHEME, _build_html
+
+
+def test_find_short_ids_in_title_basic() -> None:
+    """``find_short_ids_in_title`` extracts every short ID with its bounds."""
+    matches = find_short_ids_in_title("s003: average(s001, s002)")
+    assert [m[2] for m in matches] == ["s003", "s001", "s002"]
+    assert matches[0][0] == 0  # leading short ID starts at offset 0
+
+
+def test_find_short_ids_in_title_mixed_kinds() -> None:
+    """Image, group and signal short IDs are all detected."""
+    matches = find_short_ids_in_title("i012: derived(s001, gi003)")
+    assert [m[2] for m in matches] == ["i012", "s001", "gi003"]
+
+
+def test_find_short_ids_in_title_no_false_positives() -> None:
+    """Random ``letter+digits`` patterns are not mistaken for short IDs."""
+    # `s12345` has too many digits; `s1` has too few.
+    assert find_short_ids_in_title("s12345 then s1") == []
+    # Substrings inside a word must not match either.
+    assert find_short_ids_in_title("class s001abc") == []
+
+
+def test_build_html_skips_leading_short_id() -> None:
+    """The leading ``s001:`` part is rendered as plain text."""
+    html = _build_html("s003: average(s001, s002)")
+    # Leading "s003" must NOT be wrapped in an anchor
+    assert html.startswith("s003")
+    assert f'href="{SHORT_ID_URL_SCHEME}:s003"' not in html
+    # But s001 and s002 inside the body must be anchors
+    assert f'href="{SHORT_ID_URL_SCHEME}:s001"' in html
+    assert f'href="{SHORT_ID_URL_SCHEME}:s002"' in html
+
+
+def test_build_html_escapes_text() -> None:
+    """Surrounding text is HTML-escaped to avoid markup injection."""
+    html = _build_html("s003: <not a tag> & friends")
+    assert "&lt;not a tag&gt;" in html
+    assert "&amp;" in html
+
+
+def test_build_html_no_short_ids_returns_plain_text() -> None:
+    """Without short IDs, the output is just the escaped text."""
+    assert _build_html("Just a title") == "Just a title"