Merge pull request #114 from nauticalab/eywalker/plt-1180-restore-pipelineshow_graph-method-with-tests

Restore Pipeline.show_graph, fix graph rendering, add tests

Author: brian-arnold

.github/workflows/run-postgres-tests.yml

@@ -47,7 +47,7 @@ jobs:
         run: uv sync --locked --all-extras --dev
 
       - name: Run PostgreSQL tests
-        run: uv run pytest -v -m postgres --cov=src --cov-report=term-missing --cov-report=xml
+        run: uv run pytest -v -m postgres --postgres --cov=src --cov-report=term-missing --cov-report=xml
         env:
           PGHOST: localhost
           PGPORT: 5432

.github/workflows/run-tests.yml

@@ -44,9 +44,7 @@ jobs:
     # Only run on push/manual trigger — not on PRs — to avoid consuming SpiralDB
     # resources on every review cycle.
     # Requires SPIRAL_WORKLOAD_ID secret to be configured; skips gracefully if absent.
-    if: >
-      (github.event_name == 'push' || github.event_name == 'workflow_dispatch') &&
-      secrets.SPIRAL_WORKLOAD_ID != ''
+    if: github.event_name == 'push' || github.event_name == 'workflow_dispatch'
     needs: test
     permissions:
       id-token: write  # required to request a GitHub OIDC token for SpiralDB auth
@@ -58,21 +56,33 @@ jobs:
       SPIRAL_SERVER_URL: ${{ vars.SPIRAL_SERVER_URL || 'http://api.spiraldb.dev' }}
 
     steps:
+      - name: Check for SPIRAL_WORKLOAD_ID
+        if: env.SPIRAL_WORKLOAD_ID == ''
+        run: |
+          echo "::notice::SPIRAL_WORKLOAD_ID not set — skipping SpiralDB integration tests"
+          exit 0
+
       - uses: actions/checkout@v4
+        if: env.SPIRAL_WORKLOAD_ID != ''
 
       - name: Install uv
+        if: env.SPIRAL_WORKLOAD_ID != ''
         uses: astral-sh/setup-uv@v5
 
       - name: Set up Python 3.11
+        if: env.SPIRAL_WORKLOAD_ID != ''
         uses: actions/setup-python@v5
         with:
           python-version: "3.11"
 
       - name: Install system dependencies
+        if: env.SPIRAL_WORKLOAD_ID != ''
         run: sudo apt-get update && sudo apt-get install -y graphviz libgraphviz-dev
 
       - name: Install dependencies
+        if: env.SPIRAL_WORKLOAD_ID != ''
         run: uv sync --locked --all-extras --dev
 
       - name: Run SpiralDB integration tests
+        if: env.SPIRAL_WORKLOAD_ID != ''
         run: uv run pytest tests/test_databases/test_spiraldb_connector_integration.py -v

codecov.yml

@@ -0,0 +1,10 @@
+coverage:
+  status:
+    project:
+      default:
+        target: 70
+        threshold: 5  # allow up to 5% drop from base before failing
+    patch:
+      default:
+        target: 80
+        threshold: 5

notebooks/tutorials/01_introduction_to_orcapod.ipynb

@@ -27,29 +27,6 @@
 logger = logging.getLogger(__name__)
 
 
-# ---------------------------------------------------------------------------
-# Visualization helper (unrelated to pipeline node types)
-# ---------------------------------------------------------------------------
-
-
-class VizGraphNode:
-    def __init__(self, label: str, id: int, kernel_type: str):
-        self.label = label
-        self.id = id
-        self.kernel_type = kernel_type
-
-    def __hash__(self):
-        return hash((self.id, self.kernel_type))
-
-    def __eq__(self, other):
-        if not isinstance(other, VizGraphNode):
-            return NotImplemented
-        return (self.id, self.kernel_type) == (
-            other.id,
-            other.kernel_type,
-        )
-
-
 # ---------------------------------------------------------------------------
 # Pipeline
 # ---------------------------------------------------------------------------
@@ -533,6 +510,19 @@ def _compute_pipeline_snapshot_hash(self) -> str:
         combined = "\n".join(node_lines + edge_lines)
         return hashlib.sha256(combined.encode()).hexdigest()[:16]
 
+    def show_graph(self, **kwargs) -> str | None:
+        """Render the pipeline's node graph.
+
+        Args:
+            **kwargs: Forwarded to ``render_graph``.
+
+        Raises:
+            RuntimeError: If the pipeline has not been compiled yet.
+        """
+        if self._node_graph is None:
+            raise RuntimeError("Pipeline must be compiled before showing the graph.")
+        return render_graph(self._node_graph, **kwargs)
+
     def flush(self) -> None:
         """Flush all databases."""
         self._pipeline_database.flush()
@@ -806,8 +796,7 @@ def load(cls, path: str | Path, mode: str = "full") -> "Pipeline":
                 all_upstreams_usable = (
                     all(
                         hasattr(n, "load_status")
-                        and n.load_status
-                        in (LoadStatus.FULL, LoadStatus.READ_ONLY)
+                        and n.load_status in (LoadStatus.FULL, LoadStatus.READ_ONLY)
                         for n in upstream_nodes
                     )
                     if upstream_nodes
@@ -1141,7 +1130,7 @@ class GraphRenderer:
             "style": "filled",
             "typefontcolor": "lightgray",  # Light text for dark background
         },
-        "pod": {
+        "function": {
             "fillcolor": "#090271",  # darker navy blue
             "shape": "cylinder",
             "fontcolor": "white",
@@ -1153,26 +1142,22 @@ class GraphRenderer:
     def __init__(self):
         pass
 
-    def _sanitize_node_id(self, node_id: Any) -> str:
+    def _sanitize_node_id(self, node_id: GraphNode) -> str:
         return f"node_{hash(node_id)}"
 
-    def _create_default_html_label(self, node, node_attrs) -> str:
-        """
-        Create HTML for the label (text) section of the node
+    def _create_default_html_label(
+        self, node: GraphNode, node_attrs: dict[str, str]
+    ) -> str:
+        """Create HTML for the label (text) section of the node.
 
         Format:
-        kernel_type     (11pt, small text)
+        node_type      (11pt, small text)
         main_label     (14pt, normal text)
         """
+        main_label = str(node.label)
+        node_type = node.node_type
 
-        main_label = str(node.label) if hasattr(node, "label") else str(node)
-        kernel_type = str(node.kernel_type) if hasattr(node, "kernel_type") else ""
-
-        if not kernel_type:
-            # No kernel_type, just return main label
-            return f'<FONT POINT-SIZE="{self.DEFAULT_STYLES["main_font_size"]}">{main_label}</FONT>'
-
-        # Create HTML label: small kernel_type above, main label below
+        # Create HTML label: small node_type above, main label below
         main_size = self.DEFAULT_STYLES["main_font_size"]
         type_size = self.DEFAULT_STYLES["type_font_size"]
         font_name = self.DEFAULT_STYLES["font_name"]
@@ -1182,30 +1167,30 @@ def _create_default_html_label(self, node, node_attrs) -> str:
 
         html_label = f'''<
         <TABLE BORDER="0" CELLBORDER="0" CELLSPACING="0">
-            <TR><TD ALIGN="CENTER"><FONT POINT-SIZE="{type_size}" COLOR="{type_font_color}" FACE="{font_name}, bold">{kernel_type}</FONT></TD></TR>
+            <TR><TD ALIGN="CENTER"><FONT POINT-SIZE="{type_size}" COLOR="{type_font_color}" FACE="{font_name}, bold">{node_type}</FONT></TD></TR>
             <TR><TD ALIGN="CENTER"><FONT POINT-SIZE="{main_size}">{main_label}</FONT></TD></TR>
         </TABLE>
         >'''
 
         return html_label
 
     def _get_node_label(
-        self, node_id: Any, label_lut: dict[Any, str] | None = None
+        self,
+        node: GraphNode,
+        label_lut: dict[GraphNode, str] | None = None,
     ) -> str:
-        if label_lut and node_id in label_lut:
-            return label_lut[node_id]
-        return str(node_id)
+        if label_lut and node in label_lut:
+            return label_lut[node]
+        return str(node.label)
 
     def _get_node_attributes(
-        self, node_id: Any, style_rules: dict | None = None
+        self,
+        node: GraphNode,
+        style_rules: dict[str, dict[str, str]] | None = None,
     ) -> dict[str, str]:
-        """
-        Get styling attributes for a specific node based on its properties
-        """
-        # Use provided rules or defaults
+        """Get styling attributes for a specific node based on its node_type."""
         rules = style_rules or self.DEFAULT_STYLE_RULES
 
-        # Default attributes
         default_attrs = {
             "fillcolor": self.DEFAULT_STYLES["node_color"],
             "shape": self.DEFAULT_STYLES["node_shape"],
@@ -1216,13 +1201,8 @@ def _get_node_attributes(
             "typefontcolor": self.DEFAULT_STYLES["type_font_color"],
         }
 
-        # Check if node has kernel_type attribute
-        if hasattr(node_id, "kernel_type"):
-            kernel_type = node_id.kernel_type
-            if kernel_type in rules:
-                # Override defaults with rule-specific attributes
-                rule_attrs = rules[kernel_type].copy()
-                default_attrs.update(rule_attrs)
+        if node.node_type in rules:
+            default_attrs.update(rules[node.node_type])
 
         return default_attrs
 
@@ -1238,11 +1218,10 @@ def _merge_styles(self, **override_styles) -> dict:
     def generate_dot(
         self,
         graph: "nx.DiGraph",
-        label_lut: dict[Any, str] | None = None,
-        style_rules: dict | None = None,
+        label_lut: dict[GraphNode, str] | None = None,
+        style_rules: dict[str, dict[str, str]] | None = None,
         **style_overrides,
     ) -> str:
-        # Get final styles (defaults + overrides)
         styles = self._merge_styles(**style_overrides)
 
         import graphviz
@@ -1252,28 +1231,24 @@ def generate_dot(
         # Apply global styles
         dot.attr(rankdir=styles["rankdir"], dpi=str(styles["dpi"]))
         dot.attr(fontname=styles["font_name"])
-        if styles.get("font_size"):
-            dot.attr(fontsize=styles["fontsize"])
+        if styles.get("fontsize"):
+            dot.attr(fontsize=str(styles["fontsize"]))
         if styles["font_path"]:
             dot.attr(fontpath=styles["font_path"])
 
         # Set default edge attributes
         dot.attr("edge", color=styles["edge_color"])
 
-        # Add nodes with default attribute specific styling
-        for node_id in graph.nodes():
-            sanitized_id = self._sanitize_node_id(node_id)
+        # Add nodes with styling based on node_type
+        for node in graph.nodes():
+            sanitized_id = self._sanitize_node_id(node)
+            node_attrs = self._get_node_attributes(node, style_rules)
 
-            node_attrs = self._get_node_attributes(node_id, style_rules)
-
-            if label_lut and node_id in label_lut:
-                # Use custom label if provided
-                label = label_lut[node_id]
+            if label_lut and node in label_lut:
+                label = label_lut[node]
             else:
-                # Use default HTML label with kernel_type above main label
-                label = self._create_default_html_label(node_id, node_attrs)
+                label = self._create_default_html_label(node, node_attrs)
 
-            # Add nodes with its specific attributes
             dot.node(sanitized_id, label=label, **node_attrs)
 
         # Add edges
@@ -1287,13 +1262,13 @@ def generate_dot(
     def render_graph(
         self,
         graph: "nx.DiGraph",
-        label_lut: dict[Any, str] | None = None,
+        label_lut: dict[GraphNode, str] | None = None,
         show: bool = True,
         output_path: str | None = None,
         raw_output: bool = False,
         figsize: tuple = (12, 8),
         dpi: int = 150,
-        style_rules: dict | None = None,
+        style_rules: dict[str, dict[str, str]] | None = None,
         **style_overrides,
     ) -> str | None:
         # Always generate DOT first
@@ -1321,14 +1296,14 @@ def render_graph(
         dot.attr("edge", color=styles["edge_color"])
 
         # Add nodes with specific styling
-        for node_id in graph.nodes():
-            sanitized_id = self._sanitize_node_id(node_id)
-            node_attrs = self._get_node_attributes(node_id, style_rules)
+        for node in graph.nodes():
+            sanitized_id = self._sanitize_node_id(node)
+            node_attrs = self._get_node_attributes(node, style_rules)
 
-            if label_lut and node_id in label_lut:
-                label = label_lut[node_id]
+            if label_lut and node in label_lut:
+                label = label_lut[node]
             else:
-                label = self._create_default_html_label(node_id, node_attrs)
+                label = self._create_default_html_label(node, node_attrs)
 
             dot.node(sanitized_id, label=label, **node_attrs)
 
@@ -1367,30 +1342,28 @@ def render_graph(
 # =====================
 def render_graph(
     graph: "nx.DiGraph",
-    label_lut: dict[Any, str] | None = None,
-    style_rules: dict | None = None,
+    label_lut: dict[GraphNode, str] | None = None,
+    style_rules: dict[str, dict[str, str]] | None = None,
     **kwargs,
 ) -> str | None:
-    """
-    Convenience function with conditional node styling
+    """Convenience function with conditional node styling.
 
     Args:
-        graph: NetworkX DiGraph
-        label_lut: Optional node labels
-        style_rules: Dict mapping node attributes to styling rules
-        **kwargs: Other styling arguments
+        graph: NetworkX DiGraph whose nodes are GraphNode instances.
+        label_lut: Optional mapping from node to custom display label.
+        style_rules: Mapping from node_type to graphviz attribute overrides.
+        **kwargs: Other styling arguments forwarded to GraphRenderer.
     """
     renderer = GraphRenderer()
     return renderer.render_graph(graph, label_lut, style_rules=style_rules, **kwargs)
 
 
 def render_graph_dark_theme(
-    graph: "nx.DiGraph", label_lut: dict[Any, str] | None = None, **kwargs
+    graph: "nx.DiGraph",
+    label_lut: dict[GraphNode, str] | None = None,
+    **kwargs,
 ) -> str | None:
-    """
-    Render with dark theme - all backgrounds dark, all pod type fonts light
-    Perfect for dark themed presentations or displays
-    """
+    """Render with dark theme — dark backgrounds, light fonts."""
     renderer = GraphRenderer()
     return renderer.render_graph(
         graph, label_lut, style_rules=renderer.DARK_THEME_RULES, **kwargs
@@ -1425,29 +1398,29 @@ def create_custom_rules(
         pod_main_fcolor="white",
         source_type_fcolor="darkgray",
         operator_type_fcolor="darkgray",
-        kernel_type_fcolor="lightgray",
-    ):
-        """Create custom theme rules"""
+        node_type_fcolor="lightgray",
+    ) -> dict[str, dict[str, str]]:
+        """Create custom theme rules."""
         return {
             "source": {
                 "fillcolor": source_bg,
                 "shape": "ellipse",
                 "fontcolor": source_main_fcolor,
                 "style": "filled",
-                "type_font_color": source_type_fcolor,
+                "typefontcolor": source_type_fcolor,
             },
             "operator": {
                 "fillcolor": operator_bg,
                 "shape": "diamond",
                 "fontcolor": operator_main_fcolor,
                 "style": "filled",
-                "type_font_color": operator_type_fcolor,
+                "typefontcolor": operator_type_fcolor,
             },
             "function": {
                 "fillcolor": pod_bg,
                 "shape": "box",
                 "fontcolor": pod_main_fcolor,
                 "style": "filled,rounded",
-                "type_font_color": kernel_type_fcolor,
+                "typefontcolor": node_type_fcolor,
             },
         }