lsst-ctrl-mpexec 29.2025.3900__tar.gz → 29.2025.4100__tar.gz

{lsst_ctrl_mpexec-29.2025.3900/python/lsst_ctrl_mpexec.egg-info → lsst_ctrl_mpexec-29.2025.4100}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-ctrl-mpexec
-Version: 29.2025.3900
+Version: 29.2025.4100
 Summary: Pipeline execution infrastructure for the Rubin Observatory LSST Science Pipelines.
 Author-email: Rubin Observatory Data Management <dm-admin@lists.lsst.org>
 License: BSD 3-Clause License

{lsst_ctrl_mpexec-29.2025.3900 → lsst_ctrl_mpexec-29.2025.4100}/python/lsst/ctrl/mpexec/_pipeline_graph_factory.py

@@ -45,18 +45,30 @@ class PipelineGraphFactory:
         dimension schema.
     select_tasks : `str`, optional
         String expression that filters the tasks in the pipeline graph.
+    pipeline_graph : `lsst.pipe.base.pipeline_graph.PipelineGraph`, optional
+        Already-constructed pipeline graph.
     """
 
-    def __init__(self, pipeline: Pipeline, butler: Butler | None = None, select_tasks: str = ""):
+    def __init__(
+        self,
+        pipeline: Pipeline | None = None,
+        butler: Butler | None = None,
+        select_tasks: str = "",
+        *,
+        pipeline_graph: PipelineGraph | None = None,
+    ):
+        if pipeline is None and pipeline_graph is None:
+            raise TypeError("At least one of 'pipeline' and 'pipeline_graph' must not be `None`.")
         self._pipeline = pipeline
         self._registry = butler.registry if butler is not None else None
         self._select_tasks = select_tasks
-        self._pipeline_graph: PipelineGraph | None = None
+        self._pipeline_graph: PipelineGraph | None = pipeline_graph
         self._resolved: bool = False
         self._for_visualization_only: bool = False
 
     def __call__(self, *, resolve: bool = True, visualization_only: bool = False) -> PipelineGraph:
         if self._pipeline_graph is None:
+            assert self._pipeline is not None, "Guaranteed at construction."
             self._pipeline_graph = self._pipeline.to_graph()
             if self._select_tasks:
                 self._pipeline_graph = self._pipeline_graph.select(self._select_tasks)
@@ -71,6 +83,8 @@ class PipelineGraphFactory:
     @property
     def pipeline(self) -> Pipeline:
         """The original pipeline definition."""
+        if self._pipeline is None:
+            raise RuntimeError("Cannot obtain pipeline from pipeline graph.")
         if self._select_tasks:
             raise RuntimeError(
                 "The --select-tasks option cannot be used with operations that return or display a "
@@ -79,4 +93,8 @@ class PipelineGraphFactory:
         return self._pipeline
 
     def __bool__(self) -> bool:
-        return bool(self._pipeline)
+        if self._pipeline is not None:
+            return bool(self._pipeline)
+        else:
+            assert self._pipeline_graph is not None, "Guaranteed at construction."
+            return bool(self._pipeline_graph.tasks)

{lsst_ctrl_mpexec-29.2025.3900 → lsst_ctrl_mpexec-29.2025.4100}/python/lsst/ctrl/mpexec/cli/cmd/commands.py

@@ -35,25 +35,22 @@ from typing import Any
 
 import click
 
-import lsst.pipe.base.cli.opt as pipeBaseOpts
 from lsst.ctrl.mpexec.showInfo import ShowInfo
 from lsst.daf.butler.cli.opt import (
     collections_option,
-    config_file_option,
-    config_option,
     confirm_option,
     options_file_option,
     processes_option,
     repo_argument,
     where_option,
 )
-from lsst.daf.butler.cli.utils import MWCtxObj, catch_and_exit, option_section, unwrap
+from lsst.daf.butler.cli.utils import catch_and_exit, option_section, unwrap
 from lsst.pipe.base.quantum_reports import Report
 
 from .. import opt as ctrlMpExecOpts
 from .. import script
 from ..script import confirmable
-from ..utils import PipetaskCommand, makePipelineActions
+from ..utils import PipetaskCommand, collect_pipeline_actions
 
 epilog = unwrap(
     """Notes:
@@ -69,41 +66,6 @@ ignored.)
 )
 
 
-def _collectActions(ctx: click.Context, **kwargs: Any) -> dict[str, Any]:
-    """Extract pipeline building options, replace them with PipelineActions,
-    return updated `kwargs`.
-
-    Notes
-    -----
-    The pipeline actions (task, delete, config, config_file, and instrument)
-    must be handled in the order they appear on the command line, but the CLI
-    specification gives them all different option names. So, instead of using
-    the individual action options as they appear in kwargs (because
-    invocation order can't be known), we capture the CLI arguments by
-    overriding `click.Command.parse_args` and save them in the Context's
-    `obj` parameter. We use `makePipelineActions` to create a list of
-    pipeline actions from the CLI arguments and pass that list to the script
-    function using the `pipeline_actions` kwarg name, and remove the action
-    options from kwargs.
-    """
-    for pipelineAction in (
-        ctrlMpExecOpts.task_option.name(),
-        ctrlMpExecOpts.delete_option.name(),
-        config_option.name(),
-        config_file_option.name(),
-        pipeBaseOpts.instrument_option.name(),
-    ):
-        kwargs.pop(pipelineAction)
-
-    actions = makePipelineActions(MWCtxObj.getFrom(ctx).args)
-    pipeline_actions = []
-    for action in actions:
-        pipeline_actions.append(action)
-
-    kwargs["pipeline_actions"] = pipeline_actions
-    return kwargs
-
-
 def _unhandledShow(show: ShowInfo, cmd: str) -> None:
     if show.unhandled:
         print(
@@ -125,7 +87,7 @@ def build(ctx: click.Context, **kwargs: Any) -> None:
 
     This does not require input data to be specified.
     """
-    kwargs = _collectActions(ctx, **kwargs)
+    kwargs = collect_pipeline_actions(ctx, **kwargs)
     show = ShowInfo(kwargs.pop("show", []))
     if kwargs.get("butler_config") is not None and (
         {"pipeline-graph", "task-graph"}.isdisjoint(show.commands) and not kwargs.get("pipeline_dot")
@@ -187,7 +149,7 @@ concurrency = multiprocessing
 @catch_and_exit
 def qgraph(ctx: click.Context, **kwargs: Any) -> None:
     """Build and optionally save quantum graph."""
-    kwargs = _collectActions(ctx, **kwargs)
+    kwargs = collect_pipeline_actions(ctx, **kwargs)
     summary = kwargs.pop("summary", None)
     with coverage_context(kwargs):
         show = ShowInfo(kwargs.pop("show", []))
@@ -204,12 +166,21 @@ def qgraph(ctx: click.Context, **kwargs: Any) -> None:
                 file=sys.stderr,
             )
             return
-        if (qgraph := script.qgraph(pipeline_graph_factory, **kwargs, show=show)) is None:
+        if (
+            qgraph := script.qgraph(
+                pipeline_graph_factory,
+                **kwargs,
+                show=show,
+                # Making a summary report requires that we load the same graph
+                # components as execution.
+                for_execution=(summary is not None),
+            )
+        ) is None:
             raise click.ClickException("QuantumGraph was empty; ERROR logs above should provide details.")
         # QuantumGraph-only summary call here since script.qgraph also called
         # by run methods.
         if summary:
-            report = Report(qgraphSummary=qgraph.getSummary())
+            report = Report(qgraphSummary=qgraph._make_summary())
             with open(summary, "w") as out:
                 # Do not save fields that are not set.
                 out.write(report.model_dump_json(exclude_none=True, indent=2))
@@ -222,7 +193,7 @@ def qgraph(ctx: click.Context, **kwargs: Any) -> None:
 @catch_and_exit
 def run(ctx: click.Context, **kwargs: Any) -> None:
     """Build and execute pipeline and quantum graph."""
-    kwargs = _collectActions(ctx, **kwargs)
+    kwargs = collect_pipeline_actions(ctx, **kwargs)
     with coverage_context(kwargs):
         show = ShowInfo(kwargs.pop("show", []))
         pipeline_graph_factory = script.build(**kwargs, show=show)
@@ -233,7 +204,7 @@ def run(ctx: click.Context, **kwargs: Any) -> None:
                 file=sys.stderr,
             )
             return
-        if (qgraph := script.qgraph(pipeline_graph_factory, **kwargs, show=show)) is None:
+        if (qgraph := script.qgraph(pipeline_graph_factory, for_execution=True, **kwargs, show=show)) is None:
             raise click.ClickException("QuantumGraph was empty; ERROR logs above should provide details.")
         _unhandledShow(show, "run")
         if show.handled:

{lsst_ctrl_mpexec-29.2025.3900 → lsst_ctrl_mpexec-29.2025.4100}/python/lsst/ctrl/mpexec/cli/script/pre_exec_init_qbb.py

@@ -28,6 +28,9 @@
 from __future__ import annotations
 
 from lsst.pipe.base import BuildId, QuantumGraph
+from lsst.pipe.base.pipeline_graph import TaskImportMode
+from lsst.pipe.base.quantum_graph import PredictedQuantumGraph
+from lsst.resources import ResourcePath, ResourcePathExpression
 from lsst.utils.logging import getLogger
 
 from ..butler_factory import ButlerFactory
@@ -37,7 +40,7 @@ _LOG = getLogger(__name__)
 
 def pre_exec_init_qbb(
     butler_config: str,
-    qgraph: str,
+    qgraph: ResourcePathExpression,
     qgraph_id: str | None,
     config_search_path: list[str] | None,
     **kwargs: object,
@@ -64,11 +67,27 @@ def pre_exec_init_qbb(
         function and pass all the option kwargs to each of the script functions
         which ignore these unused kwargs.
     """
-    _LOG.verbose("Reading full quantum graph from %s.", qgraph)
-    # Load quantum graph. We do not really need individual Quanta here,
-    # but we need datastore records for initInputs, and those are only
-    # available from Quanta, so load the whole thing.
-    qg = QuantumGraph.loadUri(qgraph, graphID=BuildId(qgraph_id) if qgraph_id is not None else None)
+    qgraph = ResourcePath(qgraph)
+    match qgraph.getExtension():
+        case ".qgraph":
+            _LOG.verbose("Reading full quantum graph from %s.", qgraph)
+            qg = PredictedQuantumGraph.from_old_quantum_graph(
+                QuantumGraph.loadUri(
+                    qgraph,
+                    graphID=BuildId(qgraph_id) if qgraph_id is not None else None,
+                )
+            )
+        case ".qg":
+            _LOG.verbose("Reading init quanta from quantum graph from %s.", qgraph)
+            if qgraph_id is not None:
+                _LOG.warning("--qgraph-id is ignored when loading new '.qg' files.")
+            with PredictedQuantumGraph.open(
+                qgraph, import_mode=TaskImportMode.ASSUME_CONSISTENT_EDGES
+            ) as reader:
+                reader.read_init_quanta()
+            qg = reader.finish()
+        case ext:
+            raise ValueError(f"Unrecognized extension for quantum graph: {ext!r}")
 
     # Ensure that QBB uses shared datastore cache for writes.
     ButlerFactory.define_datastore_cache()

{lsst_ctrl_mpexec-29.2025.3900 → lsst_ctrl_mpexec-29.2025.4100}/python/lsst/ctrl/mpexec/cli/script/qgraph.py

@@ -42,6 +42,8 @@ from lsst.pipe.base.all_dimensions_quantum_graph_builder import (
 )
 from lsst.pipe.base.dot_tools import graph2dot
 from lsst.pipe.base.mermaid_tools import graph2mermaid
+from lsst.pipe.base.pipeline_graph import TaskImportMode
+from lsst.pipe.base.quantum_graph import PredictedQuantumGraph, PredictedQuantumGraphComponents
 from lsst.resources import ResourcePath, ResourcePathExpression
 from lsst.utils.iteration import ensure_iterable
 from lsst.utils.logging import getLogger
@@ -60,7 +62,7 @@ _LOG = getLogger(__name__)
 def qgraph(
     pipeline_graph_factory: PipelineGraphFactory | None,
     *,
-    qgraph: QuantumGraph | ResourcePathExpression | None,
+    qgraph: ResourcePathExpression | None,
     qgraph_id: str | None,
     qgraph_node_id: Iterable[uuid.UUID | str] | None,
     qgraph_datastore_records: bool,
@@ -85,8 +87,10 @@ def qgraph(
     mock: bool = False,
     unmocked_dataset_types: Sequence[str],
     mock_failure: Mapping[str, ForcedFailure],
+    for_execution: bool = False,
+    for_init_output_run: bool = False,
     **kwargs: object,
-) -> QuantumGraph | None:
+) -> PredictedQuantumGraph | None:
     """Implement the command line interface `pipetask qgraph` subcommand.
 
     Should only be called by command line tools and unit test code that test
@@ -97,8 +101,7 @@ def qgraph(
     pipeline_graph_factory : `..PipelineGraphFactory` or `None`
         A factory that holds the pipeline and can produce a pipeline graph.
         If this is not `None` then `qgraph` should be `None`.
-    qgraph : `lsst.pipe.base.QuantumGraph`, convertible to \
-            `lsst.resources.ResourcePath` or `None`
+    qgraph : convertible to `lsst.resources.ResourcePath`, or `None`
         URI location for a serialized quantum graph definition. If this option
         is not `None` then ``pipeline_graph_factory`` should be `None`.
     qgraph_id : `str` or `None`
@@ -179,15 +182,23 @@ def qgraph(
         List of overall-input dataset types that should not be mocked.
     mock_failure : `~collections.abc.Mapping`
         Quanta that should raise exceptions.
-    **kwargs : `object`
+    for_execution : `bool`, optional
+        If `True`, the script is being used to feed another that will execute
+        the given quanta, and hence all information needed for execution must
+        be loaded.
+    for_init_output_run : `bool`, optional
+        If `True`, the script is being used to feed another that will
+        initialize the output run, and hence all information needed to do so
+        must be loaded.
+    **kwargs : `dict` [`str`, `str`]
         Ignored; click commands may accept options for more than one script
         function and pass all the option kwargs to each of the script functions
         which ignore these unused kwargs.
 
     Returns
     -------
-    qgraph : `lsst.pipe.base.QuantumGraph` or `None`
-        The qgraph object that was created.
+    qg : `lsst.pipe.base.quantum_graph.PredictedQuantumGraph`
+        The quantum graph object that was created or loaded.
     """
     # make sure that --extend-run always enables --skip-existing
     if extend_run:
@@ -213,16 +224,43 @@ def qgraph(
     if skip_existing and run:
         skip_existing_in += (run,)
 
+    qgc: PredictedQuantumGraphComponents
     if qgraph is not None:
-        if not isinstance(qgraph, QuantumGraph):
-            # click passes empty tuple as default value for qgraph_node_id
-            nodes = qgraph_node_id or None
-            qgraph = QuantumGraph.loadUri(
-                qgraph,
-                butler.dimensions,
-                nodes=nodes,
-                graphID=BuildId(qgraph_id) if qgraph_id is not None else None,
-            )
+        # click passes empty tuple as default value for qgraph_node_id
+        quantum_ids = (
+            {uuid.UUID(q) if not isinstance(q, uuid.UUID) else q for q in qgraph_node_id}
+            if qgraph_node_id
+            else None
+        )
+        qgraph = ResourcePath(qgraph)
+        match qgraph.getExtension():
+            case ".qgraph":
+                qgc = PredictedQuantumGraphComponents.from_old_quantum_graph(
+                    QuantumGraph.loadUri(
+                        qgraph,
+                        butler.dimensions,
+                        nodes=quantum_ids,
+                        graphID=BuildId(qgraph_id) if qgraph_id is not None else None,
+                    )
+                )
+            case ".qg":
+                if qgraph_id is not None:
+                    _LOG.warning("--qgraph-id is ignored when loading new '.qg' files.")
+                if for_execution or for_init_output_run or save_qgraph or show.needs_full_qg:
+                    import_mode = TaskImportMode.ASSUME_CONSISTENT_EDGES
+                else:
+                    import_mode = TaskImportMode.DO_NOT_IMPORT
+                with PredictedQuantumGraph.open(qgraph, import_mode=import_mode) as reader:
+                    if for_execution or qgraph_dot or qgraph_mermaid or show.needs_full_qg:
+                        # This reads everything for the given quanta.
+                        reader.read_execution_quanta(quantum_ids)
+                    elif for_init_output_run:
+                        reader.read_init_quanta()
+                    else:
+                        reader.read_thin_graph()
+                    qgc = reader.components
+            case ext:
+                raise ValueError(f"Unrecognized extension for quantum graph: {ext!r}")
 
         # pipeline can not be provided in this case
         if pipeline_graph_factory:
@@ -265,38 +303,37 @@ def qgraph(
             output_run=run,
             data_id_tables=data_id_tables,
         )
-        # accumulate metadata
+        # Accumulate metadata (QB builder adds some of its own).
         metadata = {
-            "input": inputs,
-            "output": output,
             "butler_argument": str(butler_config),
-            "output_run": run,
             "extend_run": extend_run,
             "skip_existing_in": skip_existing_in,
             "skip_existing": skip_existing,
             "data_query": data_query,
         }
         assert run is not None, "Butler output run collection must be defined"
-        qgraph = graph_builder.build(metadata, attach_datastore_records=qgraph_datastore_records)
+        qgc = graph_builder.finish(
+            output, metadata=metadata, attach_datastore_records=qgraph_datastore_records
+        )
 
-    if len(qgraph) == 0:
-        # Nothing to do.
+    if not summarize_quantum_graph(qgc.header):
         return None
-    summarize_quantum_graph(qgraph)
 
     if save_qgraph:
-        _LOG.verbose("Writing QuantumGraph to %r.", save_qgraph)
-        qgraph.saveUri(save_qgraph)
+        _LOG.verbose("Writing quantum graph to %r.", save_qgraph)
+        qgc.write(save_qgraph)
+
+    qg = qgc.assemble()
 
     if qgraph_dot:
         _LOG.verbose("Writing quantum graph DOT visualization to %r.", qgraph_dot)
-        graph2dot(qgraph, qgraph_dot)
+        graph2dot(qg, qgraph_dot)  # TODO[DM-51850]: make this work
 
     if qgraph_mermaid:
         _LOG.verbose("Writing quantum graph Mermaid visualization to %r.", qgraph_mermaid)
-        graph2mermaid(qgraph, qgraph_mermaid)
+        graph2mermaid(qg, qgraph_mermaid)  # TODO[DM-51850]: make this work
 
     # optionally dump some info.
-    show.show_graph_info(qgraph, butler_config)
+    show.show_graph_info(qg, butler_config)  # TODO[DM-51850]: make this work
 
-    return qgraph
+    return qg

{lsst_ctrl_mpexec-29.2025.3900 → lsst_ctrl_mpexec-29.2025.4100}/python/lsst/ctrl/mpexec/cli/script/run.py

@@ -33,8 +33,9 @@ from typing import TYPE_CHECKING, Literal
 import astropy.units as u
 
 import lsst.utils.timer
-from lsst.pipe.base import ExecutionResources, QuantumGraph, TaskFactory
+from lsst.pipe.base import ExecutionResources, TaskFactory
 from lsst.pipe.base.mp_graph_executor import MPGraphExecutor
+from lsst.pipe.base.quantum_graph import PredictedQuantumGraph
 from lsst.pipe.base.single_quantum_executor import SingleQuantumExecutor
 from lsst.resources import ResourcePath, ResourcePathExpression
 from lsst.utils.doImport import doImportType
@@ -52,7 +53,7 @@ _LOG = getLogger(__name__)
 
 
 def run(
-    qg: QuantumGraph,
+    qg: PredictedQuantumGraph,
     *,
     task_factory: TaskFactory | None = None,
     pdb: str | None,
@@ -93,8 +94,8 @@ def run(
 
     Parameters
     ----------
-    qg : `lsst.pipe.base.QuantumGraph`
-        A QuantumGraph generated by a previous subcommand.
+    qg : `lsst.pipe.base.quantum_graph.PredictedQuantumGraph`
+        A quantum graph generated by a previous subcommand.
     task_factory : `lsst.pipe.base.TaskFactory`, optional
         A custom task factory to use.
     pdb : `str`, optional
@@ -211,19 +212,17 @@ def run(
     enable_lsst_debug = debug
     del debug
 
-    # If we have no output run specified, use the one from the graph rather
-    # than letting a new timestamped run be created.
-    if not output_run and qg.metadata and (output_run := qg.metadata.get("output_run")):
-        output_run = output_run
-
-    # Check that output run defined on command line is consistent with
-    # quantum graph.
-    if output_run and qg.metadata:
-        graph_output_run = qg.metadata.get("output_run", output_run)
-        if graph_output_run != output_run:
+    if not output_run:
+        # If we have no output run specified, use the one from the graph rather
+        # than letting a new timestamped run be created.
+        output_run = qg.header.output_run
+    else:
+        # Check that output run defined on command line is consistent with
+        # quantum graph.
+        if qg.header.output_run != output_run:
             raise ValueError(
                 f"Output run defined on command line ({output_run}) has to be "
-                f"identical to graph metadata ({graph_output_run}). "
+                f"identical to graph metadata ({qg.header.output_run}). "
                 "To update graph metadata run `pipetask update-graph-run` command."
             )
 

{lsst_ctrl_mpexec-29.2025.3900 → lsst_ctrl_mpexec-29.2025.4100}/python/lsst/ctrl/mpexec/cli/script/run_qbb.py

@@ -43,8 +43,9 @@ from lsst.daf.butler import (
     Quantum,
     QuantumBackedButler,
 )
-from lsst.pipe.base import BuildId, ExecutionResources, QuantumGraph, TaskFactory
+from lsst.pipe.base import ExecutionResources, TaskFactory
 from lsst.pipe.base.mp_graph_executor import MPGraphExecutor
+from lsst.pipe.base.quantum_graph import PredictedQuantumGraph
 from lsst.pipe.base.single_quantum_executor import SingleQuantumExecutor
 from lsst.resources import ResourcePath, ResourcePathExpression
 from lsst.utils.logging import VERBOSE, getLogger
@@ -147,31 +148,31 @@ def run_qbb(
     if not enable_implicit_threading:
         disable_implicit_threading()
 
+    # click passes empty tuple as default value for qgraph_node_id
+    quantum_ids = (
+        {uuid.UUID(q) if not isinstance(q, uuid.UUID) else q for q in qgraph_node_id}
+        if qgraph_node_id
+        else None
+    )
     # Load quantum graph.
-    nodes = qgraph_node_id or None
     with lsst.utils.timer.time_this(
         _LOG,
-        msg=f"Reading {str(len(nodes)) if nodes is not None else 'all'} quanta.",
+        msg=f"Reading {str(len(quantum_ids)) if quantum_ids is not None else 'all'} quanta.",
         level=VERBOSE,
     ) as qg_read_time:
-        qg = QuantumGraph.loadUri(
-            qgraph, nodes=nodes, graphID=BuildId(qgraph_id) if qgraph_id is not None else None
-        )
+        qg = PredictedQuantumGraph.read_execution_quanta(qgraph, quantum_ids=quantum_ids)
     job_metadata = {"qg_read_time": qg_read_time.duration, "qg_size": len(qg)}
 
-    if qg.metadata is None:
-        raise ValueError("QuantumGraph is missing metadata, cannot continue.")
-
-    summarize_quantum_graph(qg)
+    summarize_quantum_graph(qg.header)
 
-    dataset_types = {dstype.name: dstype for dstype in qg.registryDatasetTypes()}
+    dataset_types = {dtn.name: dtn.dataset_type for dtn in qg.pipeline_graph.dataset_types.values()}
 
     # Ensure that QBB uses shared datastore cache.
     ButlerFactory.define_datastore_cache()
 
     _butler_factory = _QBBFactory(
         butler_config=butler_config,
-        dimensions=qg.universe,
+        dimensions=qg.pipeline_graph.universe,
         dataset_types=dataset_types,
         config_search_path=config_search_path,
     )

{lsst_ctrl_mpexec-29.2025.3900 → lsst_ctrl_mpexec-29.2025.4100}/python/lsst/ctrl/mpexec/cli/script/update_graph_run.py

@@ -25,16 +25,20 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-from lsst.pipe.base import QuantumGraph
+import logging
+
+from lsst.pipe.base.quantum_graph import PredictedQuantumGraphComponents
 from lsst.resources import ResourcePathExpression
 
+_LOG = logging.getLogger(__name__)
+
 
 def update_graph_run(
     input_graph: ResourcePathExpression,
     run: str,
     output_graph: ResourcePathExpression,
-    metadata_run_key: str,
-    update_graph_id: bool,
+    metadata_run_key: str = "output_run",
+    update_graph_id: bool = False,
 ) -> None:
     """Update quantum graph with new output run name and dataset IDs and save
     updated graph to a file.
@@ -47,15 +51,15 @@ def update_graph_run(
         Collection name, if collection exists it must be of ``RUN`` type.
     output_graph : `~lsst.resources.ResourcePathExpression`
         Location to store updated quantum graph.
-    metadata_run_key : `str`
-        Specifies metadata key corresponding to output run name to update
-        with new run name. If metadata is missing it is not
-        updated. If metadata is present but key is missing, it will be
-        added.
+    metadata_run_key : `str`, optional
+        Ignored (overriding warns).
     update_graph_id : `bool`
-        If `True` then also update graph ID with a new unique value.
+        Ignored (overriding warns).
     """
-    qgraph = QuantumGraph.loadUri(input_graph)
-    key = metadata_run_key if metadata_run_key else None
-    qgraph.updateRun(run, metadata_key=key, update_graph_id=update_graph_id)
-    qgraph.saveUri(output_graph)
+    qgc = PredictedQuantumGraphComponents.read_execution_quanta(input_graph)
+    if metadata_run_key and metadata_run_key != "output_run":
+        _LOG.warning("--metadata-run-key is now ignored.")
+    if update_graph_id:
+        _LOG.warning("--update-graph-id is now ignored.")
+    qgc.update_output_run(run)
+    qgc.write(output_graph)