Allow partial graph components

Author: guerler

lib/galaxy/managers/history_graph.py

@@ -113,30 +113,37 @@ def build(self) -> HistoryGraphResponse:
         # Step 4-5: Build edges with batched resolution
         edges = self._build_edges(tr_ids, dataset_ids, collection_ids, node_set)
 
-        # Step 6: Apply representability — only tool_requests with both input AND output edges
-        representable_trs, omitted_count = self._filter_representable(tr_ids, edges)
+        # Step 6: Classify tool_requests by edge completeness
+        included_trs, partial_trs, omitted_count = self._classify_tool_request_completeness(tr_ids, edges)
         truncation.tool_requests_omitted = omitted_count
+        truncation.tool_requests_partial = len(partial_trs)
 
-        # Filter edges to only representable tool_requests
-        repr_tr_encoded = {self._encode("tool_request", tid) for tid in representable_trs}
+        # Filter edges to only included tool_requests (drop edges for isolated TRs)
+        incl_tr_encoded = {self._encode("tool_request", tid) for tid in included_trs}
         edges = [
             e
             for e in edges
-            if (e.source in repr_tr_encoded or not e.source.startswith("r"))
-            and (e.target in repr_tr_encoded or not e.target.startswith("r"))
+            if (e.source in incl_tr_encoded or not e.source.startswith("r"))
+            and (e.target in incl_tr_encoded or not e.target.startswith("r"))
         ]
 
-        # Final node set: all selected items + representable tool_requests
+        # Final node set: all selected items + included tool_requests
         final_dataset_ids = dataset_ids
         final_collection_ids = collection_ids
-        final_tr_ids = representable_trs
+        final_tr_ids = included_trs
 
         # Step 7: Fetch metadata
         nodes: list[GraphNode] = []
         nodes.extend(self._fetch_dataset_metadata(final_dataset_ids))
         nodes.extend(self._fetch_collection_metadata(final_collection_ids))
         nodes.extend(self._fetch_tool_request_metadata(final_tr_ids))
 
+        # Mark partial tool_requests
+        partial_tr_encoded = {self._encode("tool_request", tid) for tid in partial_trs}
+        for node in nodes:
+            if node.id in partial_tr_encoded:
+                node.partial = True
+
         # Step 8: Resolve tool names
         self._resolve_tool_names(nodes)
 
@@ -793,30 +800,46 @@ def _batch_resolve(
 
     # ── Step 6: Representability ──
 
-    def _filter_representable(self, tr_ids: set[int], edges: list[GraphEdge]) -> tuple[set[int], int]:
-        """Only include tool_requests with both input AND output edges."""
+    def _classify_tool_request_completeness(
+        self, tr_ids: set[int], edges: list[GraphEdge]
+    ) -> tuple[set[int], set[int], int]:
+        """Classify tool_requests by edge completeness within the current scope.
+
+        A tool_request is:
+        - **complete**: has at least one resolved input edge AND one resolved output edge
+        - **partial**: has edges on one side only (input OR output, not both).
+          This typically means the other side is outside the current scope window,
+          was suppressed during collapsing, or the tool genuinely has no inputs
+          (e.g. a generator). The API does not distinguish these cases.
+        - **isolated**: has no resolved edges at all. These are dropped from the graph.
+
+        Returns:
+            included: tool_requests with at least one edge (complete + partial, kept in graph)
+            partial: subset of included that are one-sided in the current scope
+            omitted_count: isolated tool_requests with no edges (dropped)
+        """
         tr_has_input: set[int] = set()
         tr_has_output: set[int] = set()
 
         for e in edges:
             if e.target.startswith("r"):
-                # This is an input edge (something → tool_request)
                 try:
                     tr_db_id = self.security.decode_id(e.target[1:])
                     tr_has_input.add(tr_db_id)
                 except Exception:
                     pass
             if e.source.startswith("r"):
-                # This is an output edge (tool_request → something)
                 try:
                     tr_db_id = self.security.decode_id(e.source[1:])
                     tr_has_output.add(tr_db_id)
                 except Exception:
                     pass
 
-        representable = tr_ids & tr_has_input & tr_has_output
-        omitted = len(tr_ids) - len(representable)
-        return representable, omitted
+        has_any_edge = (tr_has_input | tr_has_output) & tr_ids
+        has_both = tr_has_input & tr_has_output & tr_ids
+        partial = has_any_edge - has_both
+        omitted_count = len(tr_ids) - len(has_any_edge)
+        return has_any_edge, partial, omitted_count
 
     # ── Node metadata ──
 

lib/galaxy/schema/history_graph.py

@@ -3,7 +3,7 @@
     Optional,
 )
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 
 class GraphNode(BaseModel):
@@ -18,6 +18,13 @@ class GraphNode(BaseModel):
     visible: Optional[bool] = None
     tool_id: Optional[str] = None
     tool_name: Optional[str] = None
+    partial: Optional[bool] = Field(
+        default=None,
+        description="True if this tool_request has edges on only one side (input or output) "
+        "within the current graph scope. This can mean the other side is outside the scope "
+        "window, was suppressed during collapsing, or the tool genuinely has no inputs. "
+        "None for fully connected tool_requests and non-tool_request nodes.",
+    )
 
 
 class GraphEdge(BaseModel):
@@ -30,6 +37,7 @@ class TruncationInfo(BaseModel):
     item_count_capped: bool = False
     tool_request_count_capped: bool = False
     tool_requests_omitted: int = 0
+    tool_requests_partial: int = 0
     scope_type: Literal["recent", "window", "seed_centered"] = "recent"
     oldest_hid_included: Optional[int] = None
     newest_hid_included: Optional[int] = None

test/unit/app/managers/test_HistoryGraphBuilder.py

@@ -566,8 +566,8 @@ def test_hidden_non_element_hda_included(self):
         node_ids = {n.id for n in graph.nodes}
         assert hidden_enc in node_ids
 
-    def test_truncation_boundary_omits_partial_tool_requests(self):
-        """Tool_requests crossing the scope boundary are omitted by representability."""
+    def test_truncation_boundary_marks_partial_tool_requests(self):
+        """Tool_requests crossing the scope boundary are kept but marked partial."""
         history, _ = self._create_history()
         # Create chain: input -> tr -> output
         input_hda = self._create_hda(history, name="input")
@@ -577,13 +577,14 @@ def test_truncation_boundary_omits_partial_tool_requests(self):
         self._link_job_input_hda(job, input_hda)
         self._link_job_output_hda(job, output_hda)
 
-        # Use limit=1 — only one item in scope, tool_request can't have both input+output
+        # Use limit=1 — only one item in scope, tool_request has only one side
         graph = self._build_graph(history, limit=1)
 
-        # The tool_request should be omitted (not representable with only 1 item)
+        # The tool_request should be present but marked partial
         tr_nodes = [n for n in graph.nodes if n.type == "tool_request"]
-        assert len(tr_nodes) == 0
-        assert graph.truncated.tool_requests_omitted >= 1
+        assert len(tr_nodes) == 1
+        assert tr_nodes[0].partial is True
+        assert graph.truncated.tool_requests_partial >= 1
         assert graph.truncated.item_count_capped is True
 
     def test_deleted_items_with_include_deleted(self):
@@ -905,11 +906,11 @@ def test_pagination_newer_than_hid(self):
             assert n.hid > boundary_hid, f"Node hid {n.hid} should be > {boundary_hid}"
         assert len(graph.nodes) == 3  # hdas[3], hdas[4], hdas[5]
 
-    def test_pagination_boundary_tool_requests_omitted(self):
-        """Tool_request with input on one page and output on another is omitted.
+    def test_pagination_boundary_marks_partial_tool_requests(self):
+        """Tool_request with input on one page and output on another is marked partial.
 
         When pagination splits a tool chain, tool_requests that lose either
-        their input or output edge are omitted by representability.
+        their input or output edge are kept but marked partial.
         """
         history, _ = self._create_history()
         input_hda = self._create_hda(history, name="input")
@@ -919,16 +920,19 @@ def test_pagination_boundary_tool_requests_omitted(self):
         self._link_job_input_hda(job, input_hda)
         self._link_job_output_hda(job, output_hda)
 
-        # Full graph: tool_request is representable
+        # Full graph: tool_request is fully representable
         full = self._build_graph(history)
-        assert any(n.type == "tool_request" for n in full.nodes)
-        assert full.truncated.tool_requests_omitted == 0
+        full_tr = [n for n in full.nodes if n.type == "tool_request"]
+        assert len(full_tr) == 1
+        assert full_tr[0].partial is None
+        assert full.truncated.tool_requests_partial == 0
 
-        # Page with only the input (older items): tool_request loses its output
+        # Page with only the input (older items): tool_request loses its output → partial
         graph = self._build_graph(history, older_than_hid=output_hda.hid)
         tr_nodes = [n for n in graph.nodes if n.type == "tool_request"]
-        assert len(tr_nodes) == 0
-        assert graph.truncated.tool_requests_omitted >= 1
+        assert len(tr_nodes) == 1
+        assert tr_nodes[0].partial is True
+        assert graph.truncated.tool_requests_partial >= 1
 
     def test_stability_new_items_shift_recent_window(self):
         """Adding new items shifts the recent-overview window.
@@ -1141,17 +1145,24 @@ def test_deep_linear_chain(self):
         item_nodes = [nd for nd in graph.nodes if nd.type != "tool_request"]
         assert len(item_nodes) <= limit
 
-        # For linear chain: each representable TR has exactly 2 edges
+        # For linear chain: each full TR has 2 edges, partial TRs have 1
         tr_nodes = [nd for nd in graph.nodes if nd.type == "tool_request"]
-        assert len(graph.edges) == 2 * len(tr_nodes)
+        full_trs = [nd for nd in tr_nodes if not nd.partial]
+        partial_trs = [nd for nd in tr_nodes if nd.partial]
+        assert len(graph.edges) == 2 * len(full_trs) + len(partial_trs)
 
-        # Representability: every TR node has both input and output edges
-        for tr_node in tr_nodes:
+        # Full TRs have both input and output edges
+        for tr_node in full_trs:
             incoming = [e for e in graph.edges if e.target == tr_node.id]
             outgoing = [e for e in graph.edges if e.source == tr_node.id]
             assert len(incoming) >= 1
             assert len(outgoing) >= 1
 
+        # Partial TRs have at least one edge
+        for tr_node in partial_trs:
+            edges = [e for e in graph.edges if e.target == tr_node.id or e.source == tr_node.id]
+            assert len(edges) >= 1
+
     def test_collection_heavy_map_over(self):
         """M collections × K elements each, with map-over tool execution.