lsst-pipe-base 29.2025.3400__tar.gz → 29.2025.3500__tar.gz

{lsst_pipe_base-29.2025.3400/python/lsst_pipe_base.egg-info → lsst_pipe_base-29.2025.3500}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-pipe-base
-Version: 29.2025.3400
+Version: 29.2025.3500
 Summary: Pipeline infrastructure for the Rubin Science Pipelines.
 Author-email: Rubin Observatory Data Management <dm-admin@lists.lsst.org>
 License: BSD 3-Clause License

{lsst_pipe_base-29.2025.3400 → lsst_pipe_base-29.2025.3500}/python/lsst/pipe/base/dot_tools.py

@@ -38,17 +38,12 @@ __all__ = ["graph2dot", "pipeline2dot"]
 # -------------------------------
 import html
 import io
-import re
 from collections.abc import Iterable
 from typing import TYPE_CHECKING, Any
 
 # -----------------------------
 #  Imports for other modules --
 # -----------------------------
-from lsst.daf.butler import DatasetType, DimensionUniverse
-
-from . import connectionTypes
-from .connections import iterConnections
 from .pipeline import Pipeline
 
 if TYPE_CHECKING:
@@ -234,7 +229,7 @@ def pipeline2dot(pipeline: Pipeline | Iterable[TaskDef], file: Any) -> None:
 
     Parameters
     ----------
-    pipeline : `lsst.pipe.base.Pipeline`
+    pipeline : `.Pipeline` or `~collections.abc.Iterable` [ `.TaskDef` ]
         Pipeline description.
     file : `str` or file object
         File where GraphViz graph (DOT language) is written, can be a file name
@@ -247,30 +242,7 @@ def pipeline2dot(pipeline: Pipeline | Iterable[TaskDef], file: Any) -> None:
     ImportError
         Raised if the task class cannot be imported.
     """
-    universe = DimensionUniverse()
-
-    def expand_dimensions(connection: connectionTypes.BaseConnection) -> list[str]:
-        """Return expanded list of dimensions, with special skypix treatment.
-
-        Parameters
-        ----------
-        connection : `list` [`str`]
-            Connection to examine.
-
-        Returns
-        -------
-        dimensions : `list` [`str`]
-            Expanded list of dimensions.
-        """
-        dimension_set = set()
-        if isinstance(connection, connectionTypes.DimensionedConnection):
-            dimension_set = set(connection.dimensions)
-        skypix_dim = []
-        if "skypix" in dimension_set:
-            dimension_set.remove("skypix")
-            skypix_dim = ["skypix"]
-        dimensions = universe.conform(dimension_set)
-        return list(dimensions.names) + skypix_dim
+    from .pipeline_graph import PipelineGraph, visualization
 
     # open a file if needed
     close = False
@@ -278,76 +250,19 @@ def pipeline2dot(pipeline: Pipeline | Iterable[TaskDef], file: Any) -> None:
         file = open(file, "w")
         close = True
 
-    print("digraph Pipeline {", file=file)
-    _renderDefault("graph", _ATTRIBS["defaultGraph"], file)
-    _renderDefault("node", _ATTRIBS["defaultNode"], file)
-    _renderDefault("edge", _ATTRIBS["defaultEdge"], file)
-
-    allDatasets: set[str | tuple[str, str]] = set()
     if isinstance(pipeline, Pipeline):
-        # TODO: DM-40639 will rewrite this code and finish off the deprecation
-        # of toExpandedPipeline but for now use the compatibility API.
-        pipeline = pipeline.to_graph()._iter_task_defs()
-
-    # The next two lines are a workaround until DM-29658 at which time metadata
-    # connections should start working with the above code
-    labelToTaskName = {}
-    metadataNodesToLink = set()
-
-    for idx, taskDef in enumerate(sorted(pipeline, key=lambda x: x.label)):
-        # node for a task
-        taskNodeName = f"task{idx}"
-
-        # next line is workaround until DM-29658
-        labelToTaskName[taskDef.label] = taskNodeName
-
-        _renderTaskNode(taskNodeName, taskDef, file, None)
-
-        metadataRePattern = re.compile("^(.*)_metadata$")
-        for attr in sorted(iterConnections(taskDef.connections, "inputs"), key=lambda x: x.name):
-            if attr.name not in allDatasets:
-                dimensions = expand_dimensions(attr)
-                _renderDSTypeNode(attr.name, dimensions, file)
-                allDatasets.add(attr.name)
-            nodeName, component = DatasetType.splitDatasetTypeName(attr.name)
-            _renderEdge(attr.name, taskNodeName, file)
-            # connect component dataset types to the composite type that
-            # produced it
-            if component is not None and (nodeName, attr.name) not in allDatasets:
-                _renderEdge(nodeName, attr.name, file)
-                allDatasets.add((nodeName, attr.name))
-                if nodeName not in allDatasets:
-                    dimensions = expand_dimensions(attr)
-                    _renderDSTypeNode(nodeName, dimensions, file)
-            # The next if block is a workaround until DM-29658 at which time
-            # metadata connections should start working with the above code
-            if (match := metadataRePattern.match(attr.name)) is not None:
-                matchTaskLabel = match.group(1)
-                metadataNodesToLink.add((matchTaskLabel, attr.name))
-
-        for attr in sorted(iterConnections(taskDef.connections, "prerequisiteInputs"), key=lambda x: x.name):
-            if attr.name not in allDatasets:
-                dimensions = expand_dimensions(attr)
-                _renderDSTypeNode(attr.name, dimensions, file)
-                allDatasets.add(attr.name)
-            # use dashed line for prerequisite edges to distinguish them
-            _renderEdge(attr.name, taskNodeName, file, style="dashed")
-
-        for attr in sorted(iterConnections(taskDef.connections, "outputs"), key=lambda x: x.name):
-            if attr.name not in allDatasets:
-                dimensions = expand_dimensions(attr)
-                _renderDSTypeNode(attr.name, dimensions, file)
-                allDatasets.add(attr.name)
-            _renderEdge(taskNodeName, attr.name, file)
-
-    # This for loop is a workaround until DM-29658 at which time metadata
-    # connections should start working with the above code
-    for matchLabel, dsTypeName in metadataNodesToLink:
-        # only render an edge to metadata if the label is part of the current
-        # graph
-        if (result := labelToTaskName.get(matchLabel)) is not None:
-            _renderEdge(result, dsTypeName, file)
+        pg = pipeline.to_graph(visualization_only=True)
+    else:
+        pg = PipelineGraph()
+        for task_def in pipeline:
+            pg.add_task(
+                task_def.label,
+                task_class=task_def.taskClass,
+                config=task_def.config,
+                connections=task_def.connections,
+            )
+        pg.resolve(visualization_only=True)
+    visualization.show_dot(pg, stream=file, dataset_types=True)
 
-    print("}", file=file)
     if close:
         file.close()

{lsst_pipe_base-29.2025.3400 → lsst_pipe_base-29.2025.3500}/python/lsst/pipe/base/graph/graph.py

@@ -191,10 +191,10 @@ class QuantumGraph:
         """
         # Save packages to metadata
         self._metadata = dict(metadata) if metadata is not None else {}
-        self._metadata["packages"] = Packages.fromSystem()
-        self._metadata["user"] = getpass.getuser()
-        self._metadata["time"] = f"{datetime.datetime.now()}"
-        self._metadata["full_command"] = " ".join(sys.argv)
+        self._metadata.setdefault("packages", Packages.fromSystem())
+        self._metadata.setdefault("user", getpass.getuser())
+        self._metadata.setdefault("time", f"{datetime.datetime.now()}")
+        self._metadata.setdefault("full_command", " ".join(sys.argv))
 
         self._buildId = _buildId if _buildId is not None else BuildId(f"{time.time()}-{os.getpid()}")
         # Data structure used to identify relations between

lsst_pipe_base-29.2025.3500/python/lsst/pipe/base/mermaid_tools.py

@@ -0,0 +1,213 @@
+# This file is part of pipe_base.
+#
+# Developed for the LSST Data Management System.
+# This product includes software developed by the LSST Project
+# (http://www.lsst.org).
+# See the COPYRIGHT file at the top-level directory of this distribution
+# for details of code ownership.
+#
+# This software is dual licensed under the GNU General Public License and also
+# under a 3-clause BSD license. Recipients may choose which of these licenses
+# to use; please see the files gpl-3.0.txt and/or bsd_license.txt,
+# respectively.  If you choose the GPL option then the following text applies
+# (but note that there is still no warranty even if you opt for BSD instead):
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Module defining few methods to generate Mermaid charts from pipelines or
+quantum graphs.
+"""
+
+from __future__ import annotations
+
+__all__ = ["graph2mermaid", "pipeline2mermaid"]
+
+from collections.abc import Iterable
+from typing import TYPE_CHECKING, Any, Literal
+
+from .pipeline import Pipeline
+
+if TYPE_CHECKING:
+    from lsst.daf.butler import DatasetRef
+    from lsst.pipe.base import QuantumGraph, TaskDef
+
+
+def _datasetRefId(dsRef: DatasetRef) -> str:
+    """Make a unique identifier string for a dataset ref based on its name and
+    dataId.
+    """
+    dsIdParts = [dsRef.datasetType.name]
+    dsIdParts.extend(f"{key}_{dsRef.dataId[key]}" for key in sorted(dsRef.dataId.required.keys()))
+    return "_".join(dsIdParts)
+
+
+def _makeDatasetNode(dsRef: DatasetRef, allDatasetRefs: dict[str, str], file: Any) -> str:
+    """Create a Mermaid node for a dataset if it doesn't exist, and return its
+    node ID.
+    """
+    dsId = _datasetRefId(dsRef)
+    nodeName = allDatasetRefs.get(dsId)
+    if nodeName is None:
+        nodeName = f"DATASET_{len(allDatasetRefs)}"
+        allDatasetRefs[dsId] = nodeName
+        # Simple label: datasetType name and run.
+        label_lines = [f"**{dsRef.datasetType.name}**", f"run: {dsRef.run}"]
+        # Add dataId info.
+        for k in sorted(dsRef.dataId.required.keys()):
+            label_lines.append(f"{k}={dsRef.dataId[k]}")
+        label = "<br>".join(label_lines)
+        print(f'{nodeName}["{label}"]', file=file)
+    return nodeName
+
+
+def graph2mermaid(qgraph: QuantumGraph, file: Any) -> None:
+    """Convert QuantumGraph into a Mermaid flowchart (top-down).
+
+    This method is mostly for documentation/presentation purposes.
+
+    Parameters
+    ----------
+    qgraph : `~lsst.pipe.base.QuantumGraph`
+        QuantumGraph instance.
+    file : `str` or file object
+        File where Mermaid flowchart is written, can be a file name or file
+        object.
+
+    Raises
+    ------
+    OSError
+        Raised if the output file cannot be opened.
+    ImportError
+        Raised if the task class cannot be imported.
+    """
+    # Open a file if needed.
+    close = False
+    if not hasattr(file, "write"):
+        file = open(file, "w")
+        close = True
+
+    # Start Mermaid code block with flowchart.
+    print("flowchart TD", file=file)
+
+    # To avoid duplicating dataset nodes, we track them.
+    allDatasetRefs: dict[str, str] = {}
+
+    # Process each task/quantum.
+    for taskId, taskDef in enumerate(qgraph.taskGraph):
+        quanta = qgraph.getNodesForTask(taskDef)
+        for qId, quantumNode in enumerate(quanta):
+            # Create quantum node.
+            taskNodeName = f"TASK_{taskId}_{qId}"
+            taskLabelLines = [f"**{taskDef.label}**", f"Node ID: {quantumNode.nodeId}"]
+            dataId = quantumNode.quantum.dataId
+            if dataId is not None:
+                for k in sorted(dataId.required.keys()):
+                    taskLabelLines.append(f"{k}={dataId[k]}")
+            else:
+                raise ValueError("Quantum DataId cannot be None")
+            taskLabel = "<br>".join(taskLabelLines)
+            print(f'{taskNodeName}["{taskLabel}"]', file=file)
+
+            # Quantum inputs: datasets --> tasks
+            for dsRefs in quantumNode.quantum.inputs.values():
+                for dsRef in dsRefs:
+                    dsNode = _makeDatasetNode(dsRef, allDatasetRefs, file)
+                    print(f"{dsNode} --> {taskNodeName}", file=file)
+
+            # Quantum outputs: tasks --> datasets
+            for dsRefs in quantumNode.quantum.outputs.values():
+                for dsRef in dsRefs:
+                    dsNode = _makeDatasetNode(dsRef, allDatasetRefs, file)
+                    print(f"{taskNodeName} --> {dsNode}", file=file)
+
+    if close:
+        file.close()
+
+
+def pipeline2mermaid(
+    pipeline: Pipeline | Iterable[TaskDef],
+    file: Any,
+    show_dimensions: bool = True,
+    expand_dimensions: bool = False,
+    show_storage: bool = True,
+) -> None:
+    """Convert a Pipeline into a Mermaid flowchart diagram.
+
+    This function produces a Mermaid flowchart, representing tasks and their
+    inputs/outputs as dataset nodes. It uses a top-down layout.
+
+    This method is mostly for documentation/presentation purposes.
+
+    Parameters
+    ----------
+    pipeline : Pipeline or Iterable[TaskDef]
+        The pipeline or collection of tasks to represent.
+    file : str or file-like
+        The output file or file-like object into which the Mermaid code is
+        written.
+    show_dimensions : bool, optional
+        If True, display dimension information for tasks and datasets.
+        Default is True.
+    expand_dimensions : bool, optional
+        If True, expand dimension names to include all components. Default is
+        False.
+    show_storage : bool, optional
+        If True, display storage class information for datasets. Default is
+        True.
+
+    Raises
+    ------
+    OSError
+        Raised if the output file cannot be opened.
+    ImportError
+        Raised if the task class cannot be imported.
+    """
+    from .pipeline_graph import PipelineGraph, visualization
+
+    # Ensure that pipeline is iterable of task definitions.
+    if isinstance(pipeline, Pipeline):
+        pipeline = pipeline.to_graph()._iter_task_defs()
+
+    # Open file if needed.
+    close = False
+    if not hasattr(file, "write"):
+        file = open(file, "w")
+        close = True
+
+    if isinstance(pipeline, Pipeline):
+        pg = pipeline.to_graph(visualization_only=True)
+    else:
+        pg = PipelineGraph()
+        for task_def in pipeline:
+            pg.add_task(
+                task_def.label,
+                task_class=task_def.taskClass,
+                config=task_def.config,
+                connections=task_def.connections,
+            )
+        pg.resolve(visualization_only=True)
+
+    dimensions: Literal["full", "concise"] | None = None
+    if show_dimensions:
+        if expand_dimensions:
+            dimensions = "full"
+        else:
+            dimensions = "concise"
+
+    visualization.show_mermaid(
+        pg, stream=file, dataset_types=True, dimensions=dimensions, storage_classes=show_storage
+    )
+
+    if close:
+        file.close()

{lsst_pipe_base-29.2025.3400 → lsst_pipe_base-29.2025.3500}/python/lsst/pipe/base/mp_graph_executor.py

@@ -159,7 +159,7 @@ class _Job:
         quantumExecutor_pickle: bytes,
         task_node_pickle: bytes,
         quantum_pickle: bytes,
-        quantum_id: uuid.UUID | None,
+        quantum_id: uuid.UUID,
         logConfigState: list,
         snd_conn: multiprocessing.connection.Connection,
         fail_fast: bool,
@@ -174,6 +174,8 @@ class _Job:
             Task definition structure, pickled.
         quantum_pickle : `bytes`
             Quantum for this task execution in pickled form.
+        quantum_id : `uuid.UUID`
+            Unique ID for the quantum.
         logConfigState : `list`
             Logging state from parent process.
         snd_conn : `multiprocessing.Connection`
@@ -205,6 +207,7 @@ class _Job:
             _, report = quantumExecutor.execute(task_node, quantum, quantum_id=quantum_id)
         except RepeatableQuantumError as exc:
             report = QuantumReport.from_exception(
+                quantumId=quantum_id,
                 exception=exc,
                 dataId=quantum.dataId,
                 taskLabel=task_node.label,
@@ -220,6 +223,7 @@ class _Job:
             _LOG.fatal("Invalid quantum error for %s (%s): %s", task_node.label, quantum.dataId)
             _LOG.fatal(exc, exc_info=True)
             report = QuantumReport.from_exception(
+                quantumId=quantum_id,
                 exception=exc,
                 dataId=quantum.dataId,
                 taskLabel=task_node.label,
@@ -229,6 +233,7 @@ class _Job:
         except Exception as exc:
             _LOG.debug("exception from task %s dataId %s: %s", task_node.label, quantum.dataId, exc)
             report = QuantumReport.from_exception(
+                quantumId=quantum_id,
                 exception=exc,
                 dataId=quantum.dataId,
                 taskLabel=task_node.label,
@@ -282,6 +287,7 @@ class _Job:
             exitcode = self.process.exitcode if self.process.exitcode is not None else -1
             assert self.qnode.quantum.dataId is not None, "Quantum DataId cannot be None"
             report = QuantumReport.from_exit_code(
+                quantumId=self.qnode.nodeId,
                 exitCode=exitcode,
                 dataId=self.qnode.quantum.dataId,
                 taskLabel=self.qnode.task_node.label,
@@ -539,6 +545,7 @@ class MPGraphExecutor(QuantumGraphExecutor):
                 )
                 failedNodes.add(qnode)
                 failed_quantum_report = QuantumReport(
+                    quantumId=qnode.nodeId,
                     status=ExecutionStatus.SKIPPED,
                     dataId=qnode.quantum.dataId,
                     taskLabel=task_node.label,
@@ -576,6 +583,7 @@ class MPGraphExecutor(QuantumGraphExecutor):
                     raise
             except Exception as exc:
                 quantum_report = QuantumReport.from_exception(
+                    quantumId=qnode.nodeId,
                     exception=exc,
                     dataId=qnode.quantum.dataId,
                     taskLabel=task_node.label,
@@ -722,6 +730,7 @@ class MPGraphExecutor(QuantumGraphExecutor):
                     assert job.qnode.quantum.dataId is not None, "Quantum DataId cannot be None"
                     if jobInputNodes & jobs.failedNodes:
                         quantum_report = QuantumReport(
+                            quantumId=job.qnode.nodeId,
                             status=ExecutionStatus.SKIPPED,
                             dataId=job.qnode.quantum.dataId,
                             taskLabel=job.qnode.task_node.label,

{lsst_pipe_base-29.2025.3400 → lsst_pipe_base-29.2025.3500}/python/lsst/pipe/base/pipeline_graph/_edges.py

@@ -258,6 +258,7 @@ class Edge(ABC):
         in exported networkx graphs.
         """
         return {
+            "connection_name": self.connection_name,
             "parent_dataset_type_name": self.parent_dataset_type_name,
             "storage_class_name": self.storage_class_name,
             "is_init": bool,
@@ -606,7 +607,18 @@ class ReadEdge(Edge):
                         "type is registered."
                     )
             else:
-                all_current_components = current.storageClass.allComponents()
+                try:
+                    all_current_components = current.storageClass.allComponents()
+                except (KeyError, ImportError):
+                    if visualization_only:
+                        current = DatasetType(
+                            self.parent_dataset_type_name,
+                            dimensions,
+                            storageClass="<UNKNOWN>",
+                            isCalibration=self.is_calibration,
+                        )
+                        return current, is_initial_query_constraint, is_prerequisite
+                    raise
                 if self.component not in all_current_components:
                     raise IncompatibleDatasetTypeError(
                         f"Dataset type {self.parent_dataset_type_name!r} has storage class "
@@ -618,8 +630,10 @@ class ReadEdge(Edge):
                 # for the component the task wants, because we don't have the
                 # parent storage class.
                 current_component = all_current_components[self.component]
+
                 if (
-                    current_component.name != self.storage_class_name
+                    not visualization_only
+                    and current_component.name != self.storage_class_name
                     and not StorageClassFactory()
                     .getStorageClass(self.storage_class_name)
                     .can_convert(current_component)
@@ -652,7 +666,7 @@ class ReadEdge(Edge):
                             "compatible but different, registering the dataset type in the data repository "
                             "in advance will avoid this error."
                         )
-                elif not dataset_type.is_compatible_with(current):
+                elif not visualization_only and not dataset_type.is_compatible_with(current):
                     raise IncompatibleDatasetTypeError(
                         f"Incompatible definition for input dataset type {self.parent_dataset_type_name!r}; "
                         f"task {self.task_label!r} has {dataset_type}, but the definition "

{lsst_pipe_base-29.2025.3400 → lsst_pipe_base-29.2025.3500}/python/lsst/pipe/base/pipeline_graph/_nodes.py

@@ -27,12 +27,39 @@
 from __future__ import annotations
 
 __all__ = (
+    "NodeBipartite",
     "NodeKey",
     "NodeType",
 )
 
 import enum
-from typing import NamedTuple
+import sys
+from typing import Any, NamedTuple
+
+
+class NodeBipartite(enum.IntEnum):
+    """Constants for the 'bipartite' key in NetworkX graph views."""
+
+    DATASET_OR_TYPE = 0
+    """Value for nodes that represent dataset types (in pipeline graphs)
+    or datasets (in quantum graphs).
+    """
+
+    TASK_OR_QUANTUM = 1
+    """Value for nodes that represent tasks (in pipeline graphs) or quanta
+    (in quantum graphs).
+    """
+
+    if "sphinx" in sys.modules:
+
+        @classmethod
+        def from_bytes(cls, *args: Any, **kwargs: Any) -> Any:  # pragma: no cover
+            """See `IntEnum.from_bytes`."""
+            return super().from_bytes(*args, **kwargs)
+
+        def to_bytes(self, *args: Any, **kwargs: Any) -> Any:  # pragma: no cover
+            """See `IntEnum.to_bytes`."""
+            return super().to_bytes(self, *args, **kwargs)
 
 
 class NodeType(enum.Enum):
@@ -43,13 +70,13 @@ class NodeType(enum.Enum):
     TASK = 2
 
     @property
-    def bipartite(self) -> int:
+    def bipartite(self) -> NodeBipartite:
         """The integer used as the "bipartite" key in networkx exports of a
         `PipelineGraph`.
 
         This key is used by the `networkx.algorithms.bipartite` module.
         """
-        return int(self is not NodeType.DATASET_TYPE)
+        return NodeBipartite(self is not NodeType.DATASET_TYPE)
 
     def __lt__(self, other: NodeType) -> bool:
         # We define __lt__ only to be able to provide deterministic tiebreaking

{lsst_pipe_base-29.2025.3400 → lsst_pipe_base-29.2025.3500}/python/lsst/pipe/base/pipeline_graph/_tasks.py

@@ -806,7 +806,9 @@ class TaskNode:
         edge : `ReadEdge`
             Input edge.
         """
-        return self.inputs[connection_name]
+        if (edge := self.inputs.get(connection_name)) is not None:
+            return edge
+        return self.prerequisite_inputs[connection_name]
 
     def get_output_edge(self, connection_name: str) -> WriteEdge:
         """Look up an output edge by connection name.

{lsst_pipe_base-29.2025.3400 → lsst_pipe_base-29.2025.3500}/python/lsst/pipe/base/pipeline_graph/visualization/_dot.py

@@ -57,6 +57,7 @@ _OVERFLOW_MAX_LINES = 20
 def show_dot(
     pipeline_graph: PipelineGraph,
     stream: TextIO = sys.stdout,
+    label_edge_connections: bool = False,
     **kwargs: Any,
 ) -> None:
     """Write a DOT representation of the pipeline graph to a stream.
@@ -67,6 +68,8 @@ def show_dot(
         Pipeline graph to show.
     stream : `TextIO`, optional
         Stream to write the DOT representation to.
+    label_edge_connections : `bool`, optional
+        If `True`, label edges with their connection names.
     **kwargs
         Additional keyword arguments to pass to `parse_display_args`.
     """
@@ -96,12 +99,19 @@ def show_dot(
         formatted_overflow_ids = [f'"{overflow_id}"' for overflow_id in overflow_ids]
         print(f"{{rank=sink; {'; '.join(formatted_overflow_ids)};}}", file=stream)
 
-    for from_node, to_node, *_ in xgraph.edges:
-        if xgraph.nodes[from_node].get("is_prerequisite", False):
-            edge_data = dict(style="dashed")
-        else:
-            edge_data = {}
-        _render_edge(from_node.node_id, to_node.node_id, stream, **edge_data)
+    for from_node, to_node, edge_data in xgraph.edges(data=True):
+        edge_kwargs = {}
+        if edge_data.get("is_prerequisite", False):
+            edge_kwargs["style"] = "dashed"
+        if (connection_name := edge_data.get("connection_name", None)) is not None:
+            if (component := edge_data.get("component", None)) is not None:
+                if label_edge_connections:
+                    edge_kwargs["xlabel"] = f"{connection_name} (.{component})"
+                else:
+                    edge_kwargs["xlabel"] = f".{component}"
+            elif label_edge_connections:
+                edge_kwargs["xlabel"] = connection_name
+        _render_edge(from_node.node_id, to_node.node_id, stream, **edge_kwargs)
 
     print("}", file=stream)
 

{lsst_pipe_base-29.2025.3400 → lsst_pipe_base-29.2025.3500}/python/lsst/pipe/base/quantum_graph_builder.py

@@ -364,6 +364,9 @@ class QuantumGraphBuilder(ABC):
             # with the quanta because no quantum knows if its the only
             # consumer).
             full_skeleton.remove_orphan_datasets()
+            # Add any dimension records not handled by the subclass, and
+            # aggregate any that were added directly to data IDs.
+            full_skeleton.attach_dimension_records(self.butler, self._pipeline_graph.get_all_dimensions())
             if attach_datastore_records:
                 self._attach_datastore_records(full_skeleton)
             # TODO initialize most metadata here instead of in ctrl_mpexec.
@@ -939,7 +942,7 @@ class QuantumGraphBuilder(ABC):
         inputs: dict[DatasetKey | PrerequisiteDatasetKey, DatasetRef] = {}
         outputs_for_skip: dict[DatasetKey, DatasetRef] = {}
         outputs_in_the_way: dict[DatasetKey, DatasetRef] = {}
-        _, dataset_type_nodes = self._pipeline_graph.group_by_dimensions()[self.universe.empty]
+        _, dataset_type_nodes = self._pipeline_graph.group_by_dimensions().get(self.universe.empty, ({}, {}))
         dataset_types = [node.dataset_type for node in dataset_type_nodes.values()]
         dataset_types.extend(self._global_init_output_types.values())
         for dataset_type in dataset_types: