lsst-ctrl-bps 29.2025.3800__py3-none-any.whl → 29.2025.4000__py3-none-any.whl

lsst/ctrl/bps/bps_reports.py

@@ -27,7 +27,14 @@
 
 """Classes and functions used in reporting run status."""
 
-__all__ = ["BaseRunReport", "DetailedRunReport", "ExitCodesReport", "SummaryRunReport", "compile_job_summary"]
+__all__ = [
+    "BaseRunReport",
+    "DetailedRunReport",
+    "ExitCodesReport",
+    "SummaryRunReport",
+    "compile_code_summary",
+    "compile_job_summary",
+]
 
 import abc
 import logging
@@ -55,7 +62,7 @@ class BaseRunReport(abc.ABC):
 
     def __eq__(self, other):
         if isinstance(other, BaseRunReport):
-            return all(self._table == other._table)
+            return self._table.pformat() == other._table.pformat()
         return False
 
     def __len__(self):
@@ -195,7 +202,7 @@ class DetailedRunReport(BaseRunReport):
         job_summary = run_report.job_summary
         if job_summary is None:
             id_ = run_report.global_wms_id if use_global_id else run_report.wms_id
-            self._msg = f"WARNING: Job summary for run '{id_}' not available, report maybe incomplete."
+            self._msg = f"WARNING: Job summary for run '{id_}' not available, report may be incomplete."
             return
 
         if by_label_expected:
@@ -231,44 +238,60 @@ class ExitCodesReport(BaseRunReport):
     error handling from the wms service.
     """
 
-    def add(self, run_report, use_global_id=False):
+    def add(self, run_report: WmsRunReport, use_global_id: bool = False) -> None:
         # Docstring inherited from the base class.
 
-        # Use label ordering from the run summary as it should reflect
-        # the ordering of the pipetasks in the pipeline.
+        exit_code_summary = run_report.exit_code_summary
+        if not exit_code_summary:
+            id_ = run_report.global_wms_id if use_global_id else run_report.wms_id
+            self._msg = f"WARNING: Exit code summary for run '{id_}' not available, report may be incomplete."
+            return
+
+        warnings = []
+
+        # If available, use label ordering from the run summary as it should
+        # reflect the ordering of the pipetasks in the pipeline.
         labels = []
         if run_report.run_summary:
             for part in run_report.run_summary.split(";"):
                 label, _ = part.split(":")
                 labels.append(label)
-        else:
-            id_ = run_report.global_wms_id if use_global_id else run_report.wms_id
-            self._msg = f"WARNING: Job summary for run '{id_}' not available, report maybe incomplete."
-            return
+        if not labels:
+            labels = sorted(exit_code_summary)
+            warnings.append("WARNING: Could not determine order of pipeline, instead sorted alphabetically.")
 
         # Payload (e.g. pipetask) error codes:
         # * 1: general failure,
         # * 2: command line error (e.g. unknown command and/or option).
         pyld_error_codes = {1, 2}
 
-        exit_code_summary = run_report.exit_code_summary
+        missing_labels = set()
         for label in labels:
-            exit_codes = exit_code_summary[label]
-
-            pyld_errors = [code for code in exit_codes if code in pyld_error_codes]
-            pyld_error_count = len(pyld_errors)
-            pyld_error_summary = (
-                ", ".join(sorted(str(code) for code in set(pyld_errors))) if pyld_errors else "None"
-            )
-
-            infra_errors = [code for code in exit_codes if code not in pyld_error_codes]
-            infra_error_count = len(infra_errors)
-            infra_error_summary = (
-                ", ".join(sorted(str(code) for code in set(infra_errors))) if infra_errors else "None"
+            try:
+                exit_codes = exit_code_summary[label]
+            except KeyError:
+                missing_labels.add(label)
+            else:
+                pyld_errors = [code for code in exit_codes if code in pyld_error_codes]
+                pyld_error_count = len(pyld_errors)
+                pyld_error_summary = (
+                    ", ".join(sorted(str(code) for code in set(pyld_errors))) if pyld_errors else "None"
+                )
+
+                infra_errors = [code for code in exit_codes if code not in pyld_error_codes]
+                infra_error_count = len(infra_errors)
+                infra_error_summary = (
+                    ", ".join(sorted(str(code) for code in set(infra_errors))) if infra_errors else "None"
+                )
+
+                run = [label, pyld_error_count, pyld_error_summary, infra_error_count, infra_error_summary]
+                self._table.add_row(run)
+        if missing_labels:
+            warnings.append(
+                f"WARNING: Exit code summary was not available for job labels: {', '.join(missing_labels)}"
             )
-
-            run = [label, pyld_error_count, pyld_error_summary, infra_error_count, infra_error_summary]
-            self._table.add_row(run)
+        if warnings:
+            self._msg = "\n".join(warnings)
 
     def __str__(self):
         alignments = ["<"] + [">"] * (len(self._table.colnames) - 1)
@@ -276,7 +299,7 @@ class ExitCodesReport(BaseRunReport):
         return str("\n".join(lines))
 
 
-def compile_job_summary(report: WmsRunReport) -> None:
+def compile_job_summary(report: WmsRunReport) -> list[str]:
     """Add a job summary to the run report if necessary.
 
     If the job summary is not provided, the function will attempt to compile
@@ -289,24 +312,89 @@ def compile_job_summary(report: WmsRunReport) -> None:
     report : `lsst.ctrl.bps.WmsRunReport`
         Information about a single run.
 
-    Raises
-    ------
-    ValueError
-        Raised if the job summary *and* information about individual jobs
-        is not available.
+    Returns
+    -------
+    warnings : `list` [`str`]
+        List of messages describing any non-critical issues encountered during
+        processing. Empty if none.
     """
+    warnings: list[str] = []
+
+    # If the job summary already exists, exit early.
     if report.job_summary:
-        return
-    if not report.jobs:
-        raise ValueError("job summary cannot be compiled: information about individual jobs not available.")
-    job_summary = {}
-    by_label = group_jobs_by_label(report.jobs)
-    for label, job_group in by_label.items():
-        by_label_state = group_jobs_by_state(job_group)
-        _LOG.debug("by_label_state = %s", by_label_state)
-        counts = {state: len(jobs) for state, jobs in by_label_state.items()}
-        job_summary[label] = counts
-    report.job_summary = job_summary
+        return warnings
+
+    if report.jobs:
+        job_summary = {}
+        by_label = group_jobs_by_label(report.jobs)
+        for label, job_group in by_label.items():
+            by_label_state = group_jobs_by_state(job_group)
+            _LOG.debug("by_label_state = %s", by_label_state)
+            counts = {state: len(jobs) for state, jobs in by_label_state.items()}
+            job_summary[label] = counts
+        report.job_summary = job_summary
+    else:
+        warnings.append("information about individual jobs not available")
+
+    return warnings
+
+
+def compile_code_summary(report: WmsRunReport) -> list[str]:
+    """Add missing entries to the exit code summary if necessary.
+
+    A WMS plugin may exclude job labels for which there are no failures from
+    the exit code summary. The function will attempt to use the job summary,
+    if available, to add missing entries for these labels.
+
+    Parameters
+    ----------
+    report : `lsst.ctrl.bps.WmsRunReport`
+        Information about a single run.
+
+    Returns
+    -------
+    warnings : `list` [`str`]
+        List of messages describing any non-critical issues encountered during
+        processing. Empty if none.
+    """
+    warnings: list[str] = []
+
+    # If the job summary is not available, exit early.
+    if not report.job_summary:
+        return warnings
+
+    # A shallow copy is enough here because we won't be modifying the existing
+    # entries, only adding new ones if necessary.
+    exit_code_summary = dict(report.exit_code_summary) if report.exit_code_summary else {}
+
+    # Use the job summary to add the entries for labels with no failures
+    # *without* modifying already existing entries.
+    failure_summary = {label: states[WmsStates.FAILED] for label, states in report.job_summary.items()}
+    for label, count in failure_summary.items():
+        if count == 0:
+            exit_code_summary.setdefault(label, [])
+
+    # Check if there are any discrepancies between the data in the exit code
+    # summary and the job summary.
+    code_summary_labels = set(exit_code_summary)
+    failure_summary_labels = set(failure_summary)
+    mismatches = {
+        label
+        for label in failure_summary_labels & code_summary_labels
+        if len(exit_code_summary[label]) != failure_summary[label]
+    }
+    if mismatches:
+        warnings.append(
+            f"number of exit codes differs from number of failures for job labels: {', '.join(mismatches)}"
+        )
+    missing = failure_summary_labels - code_summary_labels
+    if missing:
+        warnings.append(f"exit codes not available for job labels: {', '.join(missing)}")
+
+    if exit_code_summary:
+        report.exit_code_summary = exit_code_summary
+
+    return warnings
 
 
 def group_jobs_by_state(jobs):

lsst/ctrl/bps/bps_utils.py

@@ -146,7 +146,7 @@ def create_job_quantum_graph_filename(config, job, out_prefix=None):
     found, subdir = config.search("subDirTemplate", opt={"curvals": curvals})
     if not found:
         subdir = "{job.label}"
-    full_filename = Path("inputs") / subdir / f"quantum_{job.name}.qgraph"
+    full_filename = Path("inputs") / subdir / f"quantum_{job.name}.qg"
 
     if out_prefix is not None:
         full_filename = Path(out_prefix) / full_filename

lsst/ctrl/bps/clustered_quantum_graph.py

@@ -29,18 +29,21 @@
 a QuantumGraph.
 """
 
-__all__ = ["ClusteredQuantumGraph", "QuantaCluster"]
+from __future__ import annotations
 
+__all__ = ["ClusteredQuantumGraph", "QuantaCluster"]
 
 import logging
 import pickle
 import re
+import uuid
 from collections import Counter, defaultdict
 from pathlib import Path
 
 from networkx import DiGraph, is_directed_acyclic_graph, is_isomorphic, topological_sort
 
-from lsst.pipe.base import NodeId, QuantumGraph
+from lsst.pipe.base.pipeline_graph import TaskImportMode
+from lsst.pipe.base.quantum_graph import PredictedQuantumGraph, QuantumInfo
 from lsst.utils.iteration import ensure_iterable
 
 from .bps_draw import draw_networkx_dot
@@ -79,13 +82,17 @@ class QuantaCluster:
             self.tags = {}
 
     @classmethod
-    def from_quantum_node(cls, quantum_node, template):
-        """Create single quantum cluster from given quantum node.
+    def from_quantum_info(
+        cls, quantum_id: uuid.UUID, quantum_info: QuantumInfo, template: str
+    ) -> QuantaCluster:
+        """Create single quantum cluster from the given quantum information.
 
         Parameters
         ----------
-        quantum_node : `lsst.pipe.base.QuantumNode`
-            QuantumNode for which to make into a single quantum cluster.
+        quantum_id : `uuid.UUID`
+            ID of the quantum.
+        quantum_info : `lsst.pipe.base.quantum_graph.QuantumInfo`
+            Dictionary of additional information about the quantum.
         template : `str`
             Template for creating cluster name.
 
@@ -94,14 +101,13 @@ class QuantaCluster:
         cluster : `QuantaCluster`
             Newly created cluster containing the given quantum.
         """
-        label = quantum_node.taskDef.label
-        node_id = quantum_node.nodeId
-        data_id = quantum_node.quantum.dataId
+        label = quantum_info["task_label"]
+        data_id = quantum_info["data_id"]
 
         # Gather info for name template into a dictionary.
         info = dict(data_id.required)
         info["label"] = label
-        info["node_number"] = node_id
+        info["node_number"] = quantum_id
         _LOG.debug("template = %s", template)
         _LOG.debug("info for template = %s", info)
 
@@ -116,7 +122,7 @@ class QuantaCluster:
         _LOG.debug("template name = %s", name)
 
         cluster = QuantaCluster(name, label, info)
-        cluster.add_quantum(quantum_node.nodeId, label)
+        cluster.add_quantum(quantum_id, label)
         return cluster
 
     @property
@@ -130,24 +136,12 @@ class QuantaCluster:
         """Counts of Quanta per taskDef.label in this cluster."""
         return Counter(self._task_label_counts)
 
-    def add_quantum_node(self, quantum_node):
-        """Add a quantumNode to this cluster.
-
-        Parameters
-        ----------
-        quantum_node : `lsst.pipe.base.QuantumNode`
-            Quantum node to add.
-        """
-        _LOG.debug("quantum_node = %s", quantum_node)
-        _LOG.debug("quantum_node.nodeId = %s", quantum_node.nodeId)
-        self.add_quantum(quantum_node.nodeId, quantum_node.taskDef.label)
-
     def add_quantum(self, node_id, task_label):
         """Add a quantumNode to this cluster.
 
         Parameters
         ----------
-        node_id : `lsst.pipe.base.NodeId`
+        node_id : `uuid.UUID`
             ID for quantumNode to be added to cluster.
         task_label : `str`
             Task label for quantumNode to be added to cluster.
@@ -185,11 +179,10 @@ class ClusteredQuantumGraph:
     ----------
     name : `str`
         Name to be given to the ClusteredQuantumGraph.
-    qgraph : `lsst.pipe.base.QuantumGraph`
-        The QuantumGraph to be clustered.
+    qgraph : `lsst.pipe.base.quantum_graph.PredictedQuantumGraph`
+        The quantum graph to be clustered.
     qgraph_filename : `str`
-        Filename for given QuantumGraph if it has already been
-        serialized.
+        Filename for given quantum graph.
 
     Raises
     ------
@@ -203,11 +196,12 @@ class ClusteredQuantumGraph:
     use API over totally minimized memory usage.
     """
 
-    def __init__(self, name, qgraph, qgraph_filename=None):
+    def __init__(self, name: str, qgraph: PredictedQuantumGraph, qgraph_filename: str):
         if "/" in name:
             raise ValueError(f"name cannot have a / ({name})")
         self._name = name
         self._quantum_graph = qgraph
+        self._quantum_only_xgraph = qgraph.quantum_only_xgraph
         self._quantum_graph_filename = Path(qgraph_filename).resolve()
         self._cluster_graph = DiGraph()
 
@@ -228,22 +222,27 @@ class ClusteredQuantumGraph:
             return False
         if len(self) != len(other):
             return False
-        return self._quantum_graph == other._quantum_graph and is_isomorphic(
+        return is_isomorphic(self.qxgraph, other.qxgraph) and is_isomorphic(
             self._cluster_graph, other._cluster_graph
         )
 
     @property
-    def name(self):
+    def name(self) -> str:
         """The name of the ClusteredQuantumGraph."""
         return self._name
 
     @property
-    def qgraph(self):
-        """The QuantumGraph associated with this Clustered
+    def qgraph(self) -> PredictedQuantumGraph:
+        """The quantum graph associated with this Clustered
         QuantumGraph.
         """
         return self._quantum_graph
 
+    @property
+    def qxgraph(self) -> DiGraph:
+        """A networkx graph of all quanta."""
+        return self._quantum_only_xgraph
+
     def add_cluster(self, clusters_for_adding):
         """Add a cluster of quanta as a node in the graph.
 
@@ -286,30 +285,26 @@ class ClusteredQuantumGraph:
             raise KeyError(f"{self.name} does not have a cluster named {name}") from ex
         return attr["cluster"]
 
-    def get_quantum_node(self, id_):
-        """Retrieve a QuantumNode from the ClusteredQuantumGraph by ID.
+    def get_quantum_info(self, id_: uuid.UUID) -> QuantumInfo:
+        """Retrieve a quantum info dict from the ClusteredQuantumGraph by ID.
 
         Parameters
         ----------
-        id_ : `lsst.pipe.base.NodeId` or int
-            ID of the QuantumNode to retrieve.
+        id_ : `uuid.UUID`
+            ID of the quantum to retrieve.
 
         Returns
         -------
-        quantum_node : `lsst.pipe.base.QuantumNode`
-            QuantumNode matching given ID.
+        quantum_info : `lsst.pipe.base.quantum_graph.QuantumInfo`
+            Quantum info dictionary for the given ID.
 
         Raises
         ------
         KeyError
             Raised if the ClusteredQuantumGraph does not contain
-            a QuantumNode with given ID.
+            a quantum with given ID.
         """
-        node_id = id_
-        if isinstance(id_, int):
-            node_id = NodeId(id, self._quantum_graph.graphID)
-        _LOG.debug("get_quantum_node: node_id = %s", node_id)
-        return self._quantum_graph.getQuantumNodeByNodeId(node_id)
+        return self._quantum_only_xgraph.nodes[id_]
 
     def __iter__(self):
         """Iterate over names of clusters.
@@ -414,8 +409,8 @@ class ClusteredQuantumGraph:
 
     def save(self, filename, format_=None):
         """Save the ClusteredQuantumGraph in a format that is loadable.
-        The QuantumGraph is saved separately if hasn't already been
-        serialized.
+
+        The quantum graph is assumed to have been saved separately.
 
         Parameters
         ----------
@@ -433,14 +428,6 @@ class ClusteredQuantumGraph:
         if format_ not in {"pickle"}:
             raise RuntimeError(f"Unknown format ({format_})")
 
-        if not self._quantum_graph_filename:
-            # Create filename based on given ClusteredQuantumGraph filename
-            self._quantum_graph_filename = path.with_suffix(".qgraph")
-
-        # If QuantumGraph file doesn't already exist, save it:
-        if not Path(self._quantum_graph_filename).exists():
-            self._quantum_graph.saveUri(self._quantum_graph_filename)
-
         if format_ == "pickle":
             # Don't save QuantumGraph in same file.
             tmp_qgraph = self._quantum_graph
@@ -503,14 +490,14 @@ class ClusteredQuantumGraph:
         cgraph = None
         if format_ == "pickle":
             with open(filename, "rb") as fh:
-                cgraph = pickle.load(fh)
+                cgraph: ClusteredQuantumGraph = pickle.load(fh)
 
             # The QuantumGraph was saved separately
-            try:
-                cgraph._quantum_graph = QuantumGraph.loadUri(cgraph._quantum_graph_filename)
-            except FileNotFoundError:  # Try same path as ClusteredQuantumGraph
-                new_filename = path.parent / Path(cgraph._quantum_graph_filename).name
-                cgraph._quantum_graph = QuantumGraph.loadUri(new_filename)
+            with PredictedQuantumGraph.open(
+                cgraph._quantum_graph_filename, import_mode=TaskImportMode.DO_NOT_IMPORT
+            ) as reader:
+                reader.read_thin_graph()
+                cgraph._quantum_graph = reader.finish()
 
         return cgraph
 

lsst/ctrl/bps/drivers.py

@@ -50,7 +50,7 @@ import logging
 import os
 from pathlib import Path
 
-from lsst.pipe.base import QuantumGraph
+from lsst.pipe.base.quantum_graph import PredictedQuantumGraph
 from lsst.utils.timer import time_this
 from lsst.utils.usage import get_peak_mem_usage
 
@@ -111,7 +111,7 @@ def _init_submission_driver(config_file: str, **kwargs) -> BpsConfig:
     return config
 
 
-def acquire_qgraph_driver(config_file: str, **kwargs) -> tuple[BpsConfig, QuantumGraph]:
+def acquire_qgraph_driver(config_file: str, **kwargs) -> tuple[BpsConfig, PredictedQuantumGraph]:
     """Read a quantum graph from a file or create one from pipeline definition.
 
     Parameters
@@ -125,7 +125,7 @@ def acquire_qgraph_driver(config_file: str, **kwargs) -> tuple[BpsConfig, Quantu
     -------
     config : `lsst.ctrl.bps.BpsConfig`
         Updated configuration.
-    qgraph : `lsst.pipe.base.graph.QuantumGraph`
+    qgraph : `lsst.pipe.base.quantum_graph.PredictedQuantumGraph`
         A graph representing quanta.
     """
     config = _init_submission_driver(config_file, **kwargs)

lsst/ctrl/bps/etc/bps_defaults.yaml

@@ -1,6 +1,6 @@
 #USER pipelineYaml: "${OBS_SUBARU_DIR}/pipelines/DRP.yaml#processCcd"
 #  OR
-#USER qgraphFile: "/path/to/existing/file.qgraph"
+#USER qgraphFile: "/path/to/existing/file.qg"
 
 
 # At minimum, following group used in bps report and can be
@@ -94,7 +94,7 @@ clusterAlgorithm: lsst.ctrl.bps.quantum_clustering_funcs.single_quantum_clusteri
 
 # Templates for bps filenames
 submitPath: ${PWD}/submit/{outputRun}
-qgraphFileTemplate: "{uniqProcName}.qgraph"
+qgraphFileTemplate: "{uniqProcName}.qg"
 subDirTemplate: "{label}/{tract}/{patch}/{band}/{subfilter}/{physical_filter}/{visit}/{exposure}"
 templateDataId: "{tract}_{patch}_{band}_{visit}_{exposure}_{detector}"
 

lsst/ctrl/bps/pre_transform.py

@@ -38,7 +38,10 @@ import subprocess
 from pathlib import Path
 
 from lsst.ctrl.bps import BpsConfig, BpsSubprocessError
-from lsst.pipe.base.graph import QuantumGraph
+from lsst.pipe.base import QuantumGraph
+from lsst.pipe.base.pipeline_graph import TaskImportMode
+from lsst.pipe.base.quantum_graph import PredictedQuantumGraph
+from lsst.resources import ResourcePath
 from lsst.utils import doImport
 from lsst.utils.logging import VERBOSE
 from lsst.utils.timer import time_this, timeMethod
@@ -47,7 +50,7 @@ _LOG = logging.getLogger(__name__)
 
 
 @timeMethod(logger=_LOG, logLevel=VERBOSE)
-def acquire_quantum_graph(config: BpsConfig, out_prefix: str = "") -> tuple[str, QuantumGraph]:
+def acquire_quantum_graph(config: BpsConfig, out_prefix: str = "") -> tuple[str, PredictedQuantumGraph]:
     """Read a quantum graph from a file or create one from scratch.
 
     Parameters
@@ -62,8 +65,8 @@ def acquire_quantum_graph(config: BpsConfig, out_prefix: str = "") -> tuple[str,
     -------
     qgraph_filename : `str`
         Name of file containing QuantumGraph that was read into qgraph.
-    qgraph : `lsst.pipe.base.graph.QuantumGraph`
-        A QuantumGraph read in from pre-generated file or one that is the
+    qgraph : `lsst.pipe.base.quantum_graph.PredictedQuantumGraph`
+        A quantum graph read in from pre-generated file or one that is the
         result of running code that generates it.
     """
     # Check to see if user provided pre-generated QuantumGraph.
@@ -90,8 +93,15 @@ def acquire_quantum_graph(config: BpsConfig, out_prefix: str = "") -> tuple[str,
 
     _LOG.info("Reading quantum graph from '%s'", qgraph_filename)
     with time_this(log=_LOG, level=logging.INFO, prefix=None, msg="Completed reading quantum graph"):
-        qgraph = QuantumGraph.loadUri(qgraph_filename)
-
+        qgraph_path = ResourcePath(qgraph_filename)
+        if qgraph_path.getExtension() == ".qg":
+            with PredictedQuantumGraph.open(qgraph_path, import_mode=TaskImportMode.DO_NOT_IMPORT) as reader:
+                reader.read_thin_graph()
+                qgraph = reader.finish()
+        elif qgraph_path.getExtension() == ".qgraph":
+            qgraph = PredictedQuantumGraph.from_old_quantum_graph(QuantumGraph.loadUri(qgraph_path))
+        else:
+            raise ValueError(f"Unrecognized extension for quantum graph file: {qgraph_filename}.")
     return qgraph_filename, qgraph
 
 
@@ -244,8 +254,8 @@ def cluster_quanta(config, qgraph, name):
     ----------
     config : `lsst.ctrl.bps.BpsConfig`
         BPS configuration.
-    qgraph : `lsst.pipe.base.QuantumGraph`
-        Original full QuantumGraph for the run.
+    qgraph : `lsst.pipe.base.quantum_graph.PredictedQuantumGraph`
+        Original full quantum graph for the run.
     name : `str`
         Name for the ClusteredQuantumGraph that will be generated.
 

lsst/ctrl/bps/quantum_clustering_funcs.py

@@ -31,28 +31,31 @@ __all__ = ["check_clustering_config"]
 
 import logging
 import re
+import uuid
 from collections import defaultdict
 from typing import Any
 from uuid import UUID
 
 from networkx import DiGraph, NetworkXNoCycle, find_cycle, topological_sort
 
-from lsst.pipe.base import QuantumGraph, QuantumNode
+from lsst.pipe.base.quantum_graph import PredictedQuantumGraph, QuantumInfo
 
 from . import BpsConfig, ClusteredQuantumGraph, QuantaCluster
 
 _LOG = logging.getLogger(__name__)
 
 
-def single_quantum_clustering(config: BpsConfig, qgraph: QuantumGraph, name: str) -> ClusteredQuantumGraph:
+def single_quantum_clustering(
+    config: BpsConfig, qgraph: PredictedQuantumGraph, name: str
+) -> ClusteredQuantumGraph:
     """Create clusters with only single quantum.
 
     Parameters
     ----------
     config : `lsst.ctrl.bps.BpsConfig`
         BPS configuration.
-    qgraph : `lsst.pipe.base.QuantumGraph`
-        QuantumGraph to break into clusters for ClusteredQuantumGraph.
+    qgraph : `lsst.pipe.base.quantum_graph.PredictedQuantumGraph`
+        Quantum graph to break into clusters for ClusteredQuantumGraph.
     name : `str`
         Name to give to ClusteredQuantumGraph.
 
@@ -76,18 +79,19 @@ def single_quantum_clustering(config: BpsConfig, qgraph: QuantumGraph, name: str
     cached_template = {}
 
     # Create cluster of single quantum.
-    for qnode in qgraph:
-        if qnode.taskDef.label not in cached_template:
+    for quantum_id, quantum_info in cqgraph.qxgraph.nodes.items():
+        task_label = quantum_info["task_label"]
+        if task_label not in cached_template:
             found, template_data_id = config.search(
                 "templateDataId",
-                opt={"curvals": {"curr_pipetask": qnode.taskDef.label}, "replaceVars": False},
+                opt={"curvals": {"curr_pipetask": task_label}, "replaceVars": False},
             )
             if found:
                 template = "{label}_" + template_data_id
                 _, use_node_number = config.search(
                     "useNodeIdInClusterName",
                     opt={
-                        "curvals": {"curr_pipetask": qnode.taskDef.label},
+                        "curvals": {"curr_pipetask": task_label},
                         "replaceVars": False,
                         "default": True,
                     },
@@ -96,21 +100,21 @@ def single_quantum_clustering(config: BpsConfig, qgraph: QuantumGraph, name: str
                     template = "{node_number}_" + template
             else:
                 template = "{node_number}"
-            cached_template[qnode.taskDef.label] = template
+            cached_template[task_label] = template
 
-        cluster = QuantaCluster.from_quantum_node(qnode, cached_template[qnode.taskDef.label])
+        cluster = QuantaCluster.from_quantum_info(quantum_id, quantum_info, cached_template[task_label])
 
         # Save mapping for use when creating dependencies.
-        number_to_name[qnode.nodeId] = cluster.name
+        number_to_name[quantum_id] = cluster.name
 
         cqgraph.add_cluster(cluster)
 
     # Add cluster dependencies.
-    for qnode in qgraph:
+    for quantum_id in cqgraph.qxgraph:
         # Get child nodes.
-        children = qgraph.determineOutputsOfQuantumNode(qnode)
+        children = cqgraph.qxgraph.successors(quantum_id)
         for child in children:
-            cqgraph.add_dependency(number_to_name[qnode.nodeId], number_to_name[child.nodeId])
+            cqgraph.add_dependency(number_to_name[quantum_id], number_to_name[child])
 
     return cqgraph
 
@@ -209,15 +213,17 @@ def check_clustering_config(
     return list(topological_sort(clustered_task_graph)), ordered_tasks
 
 
-def dimension_clustering(config: BpsConfig, qgraph: QuantumGraph, name: str) -> ClusteredQuantumGraph:
+def dimension_clustering(
+    config: BpsConfig, qgraph: PredictedQuantumGraph, name: str
+) -> ClusteredQuantumGraph:
     """Follow config instructions to make clusters based upon dimensions.
 
     Parameters
     ----------
     config : `lsst.ctrl.bps.BpsConfig`
         BPS configuration.
-    qgraph : `lsst.pipe.base.QuantumGraph`
-        QuantumGraph to break into clusters for ClusteredQuantumGraph.
+    qgraph : `lsst.pipe.base.quantum_graph.PredictedQuantumGraph`
+        Quantum graph to break into clusters for ClusteredQuantumGraph.
     name : `str`
         Name to give to ClusteredQuantumGraph.
 
@@ -264,7 +270,7 @@ def dimension_clustering(config: BpsConfig, qgraph: QuantumGraph, name: str) ->
 def add_clusters_per_quantum(
     config: BpsConfig,
     label: str,
-    qgraph: QuantumGraph,
+    qgraph: PredictedQuantumGraph,
     cqgraph: ClusteredQuantumGraph,
     quantum_to_cluster: dict[UUID, str],
 ) -> None:
@@ -276,8 +282,8 @@ def add_clusters_per_quantum(
         BPS configuration.
     label : `str`
         The taskDef label for which to add clusters.
-    qgraph : `lsst.pipe.base.QuantumGraph`
-        QuantumGraph providing quanta for the clusters.
+    qgraph : `lsst.pipe.base.quantum_graph.PredictedQuantumGraph`
+        Quantum graph providing quanta for the clusters.
     cqgraph : `lsst.ctrl.bps.ClusteredQuantumGraph`
         The ClusteredQuantumGraph to which the new 1-quantum
         clusters are added (modified in method).
@@ -304,16 +310,10 @@ def add_clusters_per_quantum(
     else:
         template = "{node_number}"
 
-    # Currently getQuantaForTask is currently a mapping taskDef to
-    # Quanta, so quick enough to call repeatedly.
-    task_def = qgraph.findTaskDefByLabel(label)
-    assert task_def is not None, f"Given taskDef label ({label}) not found in QuantumGraph"  # for mypy
-    quantum_nodes = qgraph.getNodesForTask(task_def)
-
-    for qnode in quantum_nodes:
-        cluster = QuantaCluster.from_quantum_node(qnode, template)
+    for quantum_id in qgraph.quanta_by_task[label].values():
+        cluster = QuantaCluster.from_quantum_info(quantum_id, cqgraph.qxgraph.nodes[quantum_id], template)
         cqgraph.add_cluster(cluster)
-        quantum_to_cluster[qnode.nodeId] = cluster.name
+        quantum_to_cluster[quantum_id] = cluster.name
         add_cluster_dependencies(cqgraph, cluster, quantum_to_cluster)
 
 
@@ -467,7 +467,7 @@ def partition_cluster_values(
 def add_dim_clusters(
     cluster_config: BpsConfig,
     cluster_label: str,
-    qgraph: QuantumGraph,
+    qgraph: PredictedQuantumGraph,
     ordered_tasks: dict[str, DiGraph],
     cqgraph: ClusteredQuantumGraph,
     quantum_to_cluster: dict[UUID, str],
@@ -505,14 +505,15 @@ def add_dim_clusters(
     partition_values: set[str] = set()
     quanta_info: dict[str, list[dict[str, Any]]] = {}
     for task_label in topological_sort(ordered_tasks[cluster_label]):
-        # Determine cluster for each node
-        task_def = qgraph.findTaskDefByLabel(task_label)
-        assert task_def is not None  # for mypy
-        quantum_nodes = qgraph.getNodesForTask(task_def)
-
-        for qnode in quantum_nodes:
-            cluster_name, info = get_cluster_name_from_node(
-                qnode, cluster_dims, cluster_label, template, equal_dims, partition_dims
+        for quantum_id in qgraph.quanta_by_task[task_label].values():
+            cluster_name, info = get_cluster_name_from_info(
+                quantum_id,
+                cqgraph.qxgraph.nodes[quantum_id],
+                cluster_dims,
+                cluster_label,
+                template,
+                equal_dims,
+                partition_dims,
             )
             if "partition_key" in info:
                 partition_values.add(info["partition_key"])
@@ -551,23 +552,22 @@ def add_cluster_dependencies(
         from quantum_to_cluster or if their parent quantum node ids
         are missing from quantum_to_cluster.
     """
-    qgraph = cqgraph.qgraph
     for node_id in cluster.qgraph_node_ids:
-        cluster_node = qgraph.getQuantumNodeByNodeId(node_id)
-        parents = qgraph.determineInputsToQuantumNode(cluster_node)
-        for parent in parents:
+        cluster_node_info = cqgraph.get_quantum_info(node_id)
+        parents = cqgraph.qxgraph.predecessors(node_id)
+        for parent_id in parents:
             try:
-                if quantum_to_cluster[parent.nodeId] != quantum_to_cluster[node_id]:
-                    cqgraph.add_dependency(quantum_to_cluster[parent.nodeId], quantum_to_cluster[node_id])
+                if quantum_to_cluster[parent_id] != quantum_to_cluster[node_id]:
+                    cqgraph.add_dependency(quantum_to_cluster[parent_id], quantum_to_cluster[node_id])
             except KeyError as e:  # pragma: no cover
                 # For debugging a problem internal to method
-                qnode = qgraph.getQuantumNodeByNodeId(e.args[0])
+                qnode_info = cqgraph.get_quantum_info(e.args[0])
                 _LOG.error(
                     "Quanta missing when clustering: cluster node = %s, %s; missing = %s, %s",
-                    cluster_node.taskDef.label,
-                    cluster_node.quantum.dataId,
-                    qnode.taskDef.label,
-                    qnode.quantum.dataId,
+                    cluster_node_info["task_label"],
+                    cluster_node_info["data_id"],
+                    qnode_info["task_label"],
+                    qnode_info["data_id"],
                 )
                 _LOG.error(quantum_to_cluster)
                 raise
@@ -576,13 +576,13 @@ def add_cluster_dependencies(
 def add_dim_clusters_dependency(
     cluster_config: BpsConfig,
     cluster_label: str,
-    qgraph: QuantumGraph,
+    qgraph: PredictedQuantumGraph,
     ordered_tasks: dict[str, DiGraph],
     cqgraph: ClusteredQuantumGraph,
     quantum_to_cluster: dict[UUID, str],
 ) -> None:
     """Add clusters for a cluster label to a ClusteredQuantumGraph using
-       QuantumGraph dependencies as well as dimension values to help when
+       quantum graph dependencies as well as dimension values to help when
        some do not have particular dimension value.
 
     Parameters
@@ -591,8 +591,8 @@ def add_dim_clusters_dependency(
         BPS configuration for specific cluster label.
     cluster_label : `str`
         Cluster label for which to add clusters.
-    qgraph : `lsst.pipe.base.QuantumGraph`
-        QuantumGraph providing quanta for the clusters.
+    qgraph : `lsst.pipe.base.quantum_graph.PredictedQuantumGraph`
+        Quantum graph providing quanta for the clusters.
     ordered_tasks : `dict` [`str`, `networkx.DiGraph`]
         Mapping of cluster label to task label subgraph.
     cqgraph : `lsst.ctrl.bps.ClusteredQuantumGraph`
@@ -618,9 +618,9 @@ def add_dim_clusters_dependency(
     method = cluster_config["findDependencyMethod"]
     match method:
         case "source":
-            find_possible_nodes = qgraph.determineOutputsOfQuantumNode
+            find_possible_nodes = cqgraph.qxgraph.successors
         case "sink":
-            find_possible_nodes = qgraph.determineInputsToQuantumNode
+            find_possible_nodes = cqgraph.qxgraph.predecessors
             label_search_order.reverse()
         case _:
             raise RuntimeError(f"Invalid findDependencyMethod ({method})")
@@ -634,49 +634,60 @@ def add_dim_clusters_dependency(
     # quicker to check
     quanta_visited = set()
     for task_label in label_search_order:
-        task_def = qgraph.findTaskDefByLabel(task_label)
-        assert task_def is not None  # for mypy
-        for node in qgraph.getNodesForTask(task_def):
+        for quantum_id in qgraph.quanta_by_task[task_label].values():
             # skip if visited before
-            if node.nodeId in quanta_visited:
+            if quantum_id in quanta_visited:
                 continue
 
-            cluster_name, info = get_cluster_name_from_node(
-                node, cluster_dims, cluster_label, template, equal_dims, partition_dims
+            cluster_name, info = get_cluster_name_from_info(
+                quantum_id,
+                cqgraph.qxgraph.nodes[quantum_id],
+                cluster_dims,
+                cluster_label,
+                template,
+                equal_dims,
+                partition_dims,
             )
             if "partition_key" in info:
                 partition_values.add(info["partition_key"])
             quanta_info.setdefault(cluster_name, []).append(info)
-            quanta_visited.add(node.nodeId)
+            quanta_visited.add(quantum_id)
 
             # Use dependencies to find other quantum to add
             # Note: in testing, using the following code was faster than
             # using networkx descendants and ancestors functions
             # While traversing the QuantumGraph, nodes may appear
             # repeatedly in possible_nodes.
-            nodes_to_use = [node]
+            nodes_to_use = [quantum_id]
             while nodes_to_use:
                 node_to_use = nodes_to_use.pop()
-                possible_nodes = find_possible_nodes(node_to_use)
-                for possible_node in possible_nodes:
+                possible_node_ids = find_possible_nodes(node_to_use)
+                for possible_node_id in possible_node_ids:
                     # skip if visited before
-                    if possible_node.nodeId in quanta_visited:
+                    if possible_node_id in quanta_visited:
                         continue
-                    quanta_visited.add(possible_node.nodeId)
-
-                    if possible_node.taskDef.label in ordered_tasks[cluster_label]:
-                        cluster_name, info = get_cluster_name_from_node(
-                            possible_node, cluster_dims, cluster_label, template, equal_dims, partition_dims
+                    quanta_visited.add(possible_node_id)
+
+                    possible_node_info = cqgraph.qxgraph.nodes[possible_node_id]
+                    if possible_node_info["task_label"] in ordered_tasks[cluster_label]:
+                        cluster_name, info = get_cluster_name_from_info(
+                            possible_node_id,
+                            possible_node_info,
+                            cluster_dims,
+                            cluster_label,
+                            template,
+                            equal_dims,
+                            partition_dims,
                         )
                         if "partition_key" in info:
                             partition_values.add(info["partition_key"])
                         quanta_info.setdefault(cluster_name, []).append(info)
-                        nodes_to_use.append(possible_node)
+                        nodes_to_use.append(possible_node_id)
                     else:
                         _LOG.debug(
                             "label (%s) not in ordered_tasks. Not adding possible quantum %s",
-                            possible_node.taskDef.label,
-                            possible_node.nodeId,
+                            possible_node_info["task_label"],
+                            possible_node_id,
                         )
 
     make_and_add_clusters(
@@ -746,8 +757,9 @@ def make_and_add_clusters(
         add_cluster_dependencies(cqgraph, cluster, quantum_to_cluster)
 
 
-def get_cluster_name_from_node(
-    node: QuantumNode,
+def get_cluster_name_from_info(
+    quantum_id: uuid.UUID,
+    quantum_info: QuantumInfo,
     cluster_dims: list[str],
     cluster_label: str,
     template: str,
@@ -758,8 +770,10 @@ def get_cluster_name_from_node(
 
     Parameters
     ----------
-    node : `lsst.pipe.base.QuantumNode`
-        QuantumNode from which to create the cluster.
+    quantum_id : `uuid.UUID`
+        Unique ID for the quantum.
+    quantum_info : `lsst.pipe.base.quantum_graph.QuantumInfo`
+        Info dictionary from which to create the cluster.
     cluster_dims : `list` [`str`]
         Dimension names to be used when clustering.
     cluster_label : `str`
@@ -780,8 +794,8 @@ def get_cluster_name_from_node(
     """
     # Gather info for cluster name template into a dictionary.
     info: dict[str, Any] = {
-        "node_number": node.nodeId,
-        "node_label": node.taskDef.label,
+        "node_number": quantum_id,
+        "node_label": quantum_info["task_label"],
         "label": cluster_label,
     }
 
@@ -789,8 +803,7 @@ def get_cluster_name_from_node(
     all_dims = cluster_dims + partition_dims
 
     missing_info = set()
-    assert node.quantum.dataId is not None  # for mypy
-    data_id_info = dict(node.quantum.dataId.mapping)
+    data_id_info = dict(quantum_info["data_id"].mapping)
     for dim_name in all_dims:
         _LOG.debug("dim_name = %s", dim_name)
         if dim_name in data_id_info:
@@ -807,7 +820,7 @@ def get_cluster_name_from_node(
 
     if missing_info:
         raise RuntimeError(
-            f"Quantum {node.nodeId} ({data_id_info}) missing dimensions: {','.join(missing_info)}; "
+            f"Quantum {quantum_id} ({data_id_info}) missing dimensions: {','.join(missing_info)}; "
             f"required for cluster {cluster_label}"
         )
 

lsst/ctrl/bps/report.py

@@ -38,12 +38,18 @@ import sys
 from collections.abc import Callable, Sequence
 from typing import TextIO
 
-from lsst.utils import doImport
-
-from .bps_reports import DetailedRunReport, ExitCodesReport, SummaryRunReport, compile_job_summary
-from .wms_service import WmsRunReport, WmsStates
-
-BPS_POSTPROCESSORS = (compile_job_summary,)
+from lsst.utils import doImportType
+
+from .bps_reports import (
+    DetailedRunReport,
+    ExitCodesReport,
+    SummaryRunReport,
+    compile_code_summary,
+    compile_job_summary,
+)
+from .wms_service import BaseWmsService, WmsRunReport, WmsStates
+
+BPS_POSTPROCESSORS = (compile_job_summary, compile_code_summary)
 """Postprocessors for massaging run reports
 (`tuple` [`Callable` [[`WmsRunReport`], None]).
 """
@@ -111,7 +117,7 @@ def display_report(
 
             run_report.add(run, use_global_id=is_global)
             if run_report.message:
-                print(run_report.message, file=file)
+                messages.append(run_report.message)
 
             print(run_brief, file=file)
             print("\n", file=file)
@@ -132,6 +138,8 @@ def display_report(
                 ]
                 run_exits_report = ExitCodesReport(fields)
                 run_exits_report.add(run, use_global_id=is_global)
+                if run_exits_report.message:
+                    messages.append(run_exits_report.message)
                 print("\n", file=file)
                 print(run_exits_report, file=file)
                 run_exits_report.clear()
@@ -145,12 +153,13 @@ def display_report(
         print(run_brief, file=file)
 
     if messages:
-        print("\n".join(messages), file=file)
+        uniques = list(dict.fromkeys(messages))
+        print("\n".join(uniques), file=file)
         print("\n", file=file)
 
 
 def retrieve_report(
-    wms_service: str,
+    wms_service_fqn: str,
     *,
     run_id: str | None = None,
     user: str | None = None,
@@ -163,7 +172,7 @@ def retrieve_report(
 
     Parameters
     ----------
-    wms_service : `str`
+    wms_service_fqn : `str`
         Name of the WMS service class.
     run_id : `str`, optional
         A run id the report will be restricted to.
@@ -196,11 +205,21 @@ def retrieve_report(
     messages : `list` [`str`]
         Errors that happened during report retrieval and/or processing.
         Empty if no issues were encountered.
+
+    Raises
+    ------
+    TypeError
+        Raised if the WMS service class is not a subclass of BaseWmsService.
     """
-    messages = []
+    messages: list[str] = []
 
-    wms_service_class = doImport(wms_service)
+    wms_service_class = doImportType(wms_service_fqn)
+    if not issubclass(wms_service_class, BaseWmsService):
+        raise TypeError(
+            f"Invalid WMS service class '{wms_service_fqn}'; must be a subclass of BaseWmsService"
+        )
     wms_service = wms_service_class({})
+
     reports, message = wms_service.report(
         wms_workflow_id=run_id, user=user, hist=hist, pass_thru=pass_thru, is_global=is_global
     )
@@ -210,12 +229,12 @@ def retrieve_report(
     if postprocessors:
         for report in reports:
             for postprocessor in postprocessors:
-                try:
-                    postprocessor(report)
-                except Exception as exc:
-                    messages.append(
-                        f"Postprocessing error for '{report.wms_id}': {str(exc)} "
-                        f"(origin: {postprocessor.__name__})"
-                    )
+                if warnings := postprocessor(report):
+                    for warning in warnings:
+                        messages.append(
+                            f"WARNING: Report may be incomplete. "
+                            f"There was an issue with report postprocessing for '{report.wms_id}': "
+                            f"{warning} (origin: {postprocessor.__name__})"
+                        )
 
     return reports, messages

lsst/ctrl/bps/transform.py

@@ -190,16 +190,6 @@ def create_init_workflow(
     # Adjust job attributes values if necessary.
     _handle_job_values(job_values, gwjob)
 
-    # Pick a node id for each task (not quantum!) to avoid reading the entire
-    # quantum graph during the initialization stage.
-    node_ids = []
-    for task_label in qgraph.pipeline_graph.tasks:
-        task_def = qgraph.findTaskDefByLabel(task_label)
-        node = next(iter(qgraph.getNodesForTask(task_def)))
-        node_ids.append(node.nodeId)
-    gwjob.cmdvals["qgraphId"] = qgraph.graphID
-    gwjob.cmdvals["qgraphNodeId"] = ",".join(sorted([f"{node_id}" for node_id in node_ids]))
-
     init_workflow.add_job(gwjob)
     init_workflow.add_job_inputs(gwjob.name, [qgraph_gwfile])
     _enhance_command(config, init_workflow, gwjob, {})
@@ -682,14 +672,13 @@ def create_generic_workflow(
         # either common or aggregate for all Quanta in cluster.
         for node_id in iter(cluster.qgraph_node_ids):
             _LOG.debug("node_id=%s", node_id)
-            qnode = cqgraph.get_quantum_node(node_id)
+            quantum_info = cqgraph.get_quantum_info(node_id)
 
-            if qnode.taskDef.label not in cached_pipetask_values:
-                search_opt["curvals"]["curr_pipetask"] = qnode.taskDef.label
-                cached_pipetask_values[qnode.taskDef.label] = _get_job_values(
-                    config, search_opt, "runQuantumCommand"
-                )
-            _handle_job_values(cached_pipetask_values[qnode.taskDef.label], gwjob, unset_attributes)
+            task_label = quantum_info["task_label"]
+            if task_label not in cached_pipetask_values:
+                search_opt["curvals"]["curr_pipetask"] = task_label
+                cached_pipetask_values[task_label] = _get_job_values(config, search_opt, "runQuantumCommand")
+            _handle_job_values(cached_pipetask_values[task_label], gwjob, unset_attributes)
 
         # Update job with workflow attribute and profile values.
         qgraph_gwfile = _get_qgraph_gwfile(
@@ -699,7 +688,6 @@ def create_generic_workflow(
         generic_workflow.add_job(gwjob)
         generic_workflow.add_job_inputs(gwjob.name, [qgraph_gwfile])
 
-        gwjob.cmdvals["qgraphId"] = cqgraph.qgraph.graphID
         gwjob.cmdvals["qgraphNodeId"] = ",".join(
             sorted([f"{node_id}" for node_id in cluster.qgraph_node_ids])
         )

lsst/ctrl/bps/version.py

@@ -1,2 +1,2 @@
 __all__ = ["__version__"]
-__version__ = "29.2025.3800"
+__version__ = "29.2025.4000"

{lsst_ctrl_bps-29.2025.3800.dist-info → lsst_ctrl_bps-29.2025.4000.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-ctrl-bps
-Version: 29.2025.3800
+Version: 29.2025.4000
 Summary: Pluggable execution of workflow graphs from Rubin pipelines.
 Author-email: Rubin Observatory Data Management <dm-admin@lists.lsst.org>
 License: BSD 3-Clause License

{lsst_ctrl_bps-29.2025.3800.dist-info → lsst_ctrl_bps-29.2025.4000.dist-info}/RECORD

@@ -4,25 +4,25 @@ lsst/ctrl/bps/__init__.py,sha256=qNei3h4EwqUnyyCsBUkYXcRNNlSvzUzbM6Zdkd4eklE,166
 lsst/ctrl/bps/_exceptions.py,sha256=qNftFVE8yhiRD8yvACKEf5iHhi1o2eaa69ZCBvw6lDo,1974
 lsst/ctrl/bps/bps_config.py,sha256=4t1jyIBiw9leAySjkcksCaZ3CPJMOt8afxGxTEWRSyQ,18460
 lsst/ctrl/bps/bps_draw.py,sha256=Sl04jpbm6jB_5lBzfJprqnDes9t_aqQQhr0Ag5RSv-Y,1984
-lsst/ctrl/bps/bps_reports.py,sha256=j6HdAvkOBTSxSHmkx_vd04FvifToTaZVGpwfF-LIUu0,12487
-lsst/ctrl/bps/bps_utils.py,sha256=-w0HSUXKw8jgJFl28yzwJuuqLqT_UOw12_XQBELUWrE,12206
+lsst/ctrl/bps/bps_reports.py,sha256=73l5Gz00VQq8NgoBrGkvCaUQJE5kw2emhQxxzthMQzs,15574
+lsst/ctrl/bps/bps_utils.py,sha256=7SpzRjqpPNw_hVCyDRxoQ-cDvPnlzZ8k4epawAksM0Q,12202
 lsst/ctrl/bps/cancel.py,sha256=mAdBi-oUpepyo-1MCqx_I34dbm6cqT0VJu3d2-y9T2Y,3317
-lsst/ctrl/bps/clustered_quantum_graph.py,sha256=mBf8s_DlTzGCFq7aAKmD1cAXq6Cqr8QxjwpgXPOQcRc,18765
+lsst/ctrl/bps/clustered_quantum_graph.py,sha256=vpsjyzIr6e5as6rkRphrleY8q2I_8xXE3BawLGCtTlo,18167
 lsst/ctrl/bps/constants.py,sha256=dsnsNMqwU6Xl_ln6nQ0PmxsghlbBY9mLJWf2rlzYayQ,1733
 lsst/ctrl/bps/construct.py,sha256=o-JhTF_eehRiIxy3xe2UgBISyKNBg-kduthGiqfa50g,8100
-lsst/ctrl/bps/drivers.py,sha256=M_zWXvzK23MBBNvqdbJCnA_9DUCoFznCjWfwQw9BO6Q,22512
+lsst/ctrl/bps/drivers.py,sha256=yQ7bY-8Ccy_uAvw5YiQYLu9W2fkePb0Rde_xwyIXyAg,22561
 lsst/ctrl/bps/generic_workflow.py,sha256=BwEFBudncziHTZaTTknOQroY_a-33mGf-mq9PzxH8G0,53720
 lsst/ctrl/bps/initialize.py,sha256=DCQwB9ZSo_36Ncs8jMJwxKZcYCu46jjww6rzyiuMFKY,7554
 lsst/ctrl/bps/ping.py,sha256=orwTZUNFtlexMYFcNWW_48jaa7Jo1oK4_eb_HuC-p5E,2235
-lsst/ctrl/bps/pre_transform.py,sha256=mPUW1QuHwgkSgZGVK6xO4RN590z4g1zf3p4kNsx_yOg,10222
+lsst/ctrl/bps/pre_transform.py,sha256=uxhSiG-_NyX175nL7d1dvOmLprdbN_gxaWr7X7nzhXE,10931
 lsst/ctrl/bps/prepare.py,sha256=Fa2OEQIo4Pa8R5WmRo0PvJgXWNjynRijATvu1x80qlw,3129
-lsst/ctrl/bps/quantum_clustering_funcs.py,sha256=8fidDw53MpcqeWVXs0F0jIvSU0fLV_-1fEbC-Jhqg28,31816
-lsst/ctrl/bps/report.py,sha256=6qCt6-0apuVZrevtQzJLRmQc_ve_uPyNH3HkgC5KSjc,7898
+lsst/ctrl/bps/quantum_clustering_funcs.py,sha256=UuVHtwsoSIUJnAPyoIGX46TzoZRD6gIzgNrPFPaq3G8,32143
+lsst/ctrl/bps/report.py,sha256=893m2KBBaQouAml8DKmmVxBo-Q7fFizxl_OT6wyFBXk,8575
 lsst/ctrl/bps/restart.py,sha256=yVwxeviLiehyIfPmwU-H3tJ9ou7OWZZcrNf8PMxjr8o,2298
 lsst/ctrl/bps/status.py,sha256=Lrt0cAqROv77B8UvYXGimCa4cDHBD1N0K2Xx7oS6fXk,3362
 lsst/ctrl/bps/submit.py,sha256=Ev-yhcoZwtBPIo5bRt_4XFJRtgQBd8JHUurEfn01HpU,2880
-lsst/ctrl/bps/transform.py,sha256=P3dGwKStoCLOn7F2Oez6B__f7bGV5jlUF_Vj9lJQcU0,35256
-lsst/ctrl/bps/version.py,sha256=1tuAAU5Re7MRhtcbYlCODj58a79T6z8ie3-QgPCtLgE,55
+lsst/ctrl/bps/transform.py,sha256=y_78yBO17T4oBJ-3tCKtMwcgaT45XrLxwtEEr1vUIMQ,34687
+lsst/ctrl/bps/version.py,sha256=OZgl6BR-Rxy62NJlHO2yg_Rq4EhfmRSKDkEEnAyc-3Q,55
 lsst/ctrl/bps/wms_service.py,sha256=l3T6i1MG72dhHY0KXMUlBjWUpCLOfaySs7o2W8oCwhs,18891
 lsst/ctrl/bps/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lsst/ctrl/bps/cli/bps.py,sha256=CHfAL-U4mSi-FqeGKtmkX5nI5H9gkRre4XEWNVdeMRk,2559
@@ -32,16 +32,16 @@ lsst/ctrl/bps/cli/opt/__init__.py,sha256=6-bAftMGxt_uEKrQl0gtrg8dJLBNsPd_DWCApg_
 lsst/ctrl/bps/cli/opt/arguments.py,sha256=Q9nU1Ad1CRv0HgIM68bu6sqCfJT1om-ARZy7pVXGJ94,1534
 lsst/ctrl/bps/cli/opt/option_groups.py,sha256=xylZX9CmxrTg1FJQ0ziyWYF0Se6CvO6ydgAwUZFTkR4,2722
 lsst/ctrl/bps/cli/opt/options.py,sha256=pZQpjJ2Vrx6kYJGs5vVERBMFstPocwBXHffxkWkmavg,3088
-lsst/ctrl/bps/etc/bps_defaults.yaml,sha256=UwKAKWl09-Xjtl6kiz-AiXA9SDczeCvPGRXOPG3fzb8,4828
+lsst/ctrl/bps/etc/bps_defaults.yaml,sha256=wYIF5qqqw3KnEBGHxDscCLzFSK-kKSj_NLbPSmf-8Rg,4820
 lsst/ctrl/bps/tests/config_test_utils.py,sha256=WM8Vrigk4OO0TBoL1A73a6hLhf2a6-ACD20fROJ0U7A,3537
 lsst/ctrl/bps/tests/gw_test_utils.py,sha256=zVVQqzwSiQgPgk9TnqDzgR7uDnaTMeuBLYKA8vOp5RI,22452
-lsst_ctrl_bps-29.2025.3800.dist-info/licenses/COPYRIGHT,sha256=Lc6NoAEFQ65v_SmtS9NwfHTOuSUtC2Umbjv5zyowiQM,61
-lsst_ctrl_bps-29.2025.3800.dist-info/licenses/LICENSE,sha256=pRExkS03v0MQW-neNfIcaSL6aiAnoLxYgtZoFzQ6zkM,232
-lsst_ctrl_bps-29.2025.3800.dist-info/licenses/bsd_license.txt,sha256=7MIcv8QRX9guUtqPSBDMPz2SnZ5swI-xZMqm_VDSfxY,1606
-lsst_ctrl_bps-29.2025.3800.dist-info/licenses/gpl-v3.0.txt,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-lsst_ctrl_bps-29.2025.3800.dist-info/METADATA,sha256=aHhvIlTTGIT0HrxaLiIfbWUSw7LRuvWzsiHKBZMzfjo,2190
-lsst_ctrl_bps-29.2025.3800.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lsst_ctrl_bps-29.2025.3800.dist-info/entry_points.txt,sha256=d6FhN79h7s9frdBI7YkScsGEInwpGGub49pAjXWbIbI,51
-lsst_ctrl_bps-29.2025.3800.dist-info/top_level.txt,sha256=eUWiOuVVm9wwTrnAgiJT6tp6HQHXxIhj2QSZ7NYZH80,5
-lsst_ctrl_bps-29.2025.3800.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-lsst_ctrl_bps-29.2025.3800.dist-info/RECORD,,
+lsst_ctrl_bps-29.2025.4000.dist-info/licenses/COPYRIGHT,sha256=Lc6NoAEFQ65v_SmtS9NwfHTOuSUtC2Umbjv5zyowiQM,61
+lsst_ctrl_bps-29.2025.4000.dist-info/licenses/LICENSE,sha256=pRExkS03v0MQW-neNfIcaSL6aiAnoLxYgtZoFzQ6zkM,232
+lsst_ctrl_bps-29.2025.4000.dist-info/licenses/bsd_license.txt,sha256=7MIcv8QRX9guUtqPSBDMPz2SnZ5swI-xZMqm_VDSfxY,1606
+lsst_ctrl_bps-29.2025.4000.dist-info/licenses/gpl-v3.0.txt,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+lsst_ctrl_bps-29.2025.4000.dist-info/METADATA,sha256=QLzpoPS9PyGTZ-1lgk8iceVvuEkxgiCuSYxB_fDoqLw,2190
+lsst_ctrl_bps-29.2025.4000.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lsst_ctrl_bps-29.2025.4000.dist-info/entry_points.txt,sha256=d6FhN79h7s9frdBI7YkScsGEInwpGGub49pAjXWbIbI,51
+lsst_ctrl_bps-29.2025.4000.dist-info/top_level.txt,sha256=eUWiOuVVm9wwTrnAgiJT6tp6HQHXxIhj2QSZ7NYZH80,5
+lsst_ctrl_bps-29.2025.4000.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+lsst_ctrl_bps-29.2025.4000.dist-info/RECORD,,