lsst-ctrl-bps-panda 29.2025.4300__tar.gz → 29.2025.4500__tar.gz

{lsst_ctrl_bps_panda-29.2025.4300/python/lsst_ctrl_bps_panda.egg-info → lsst_ctrl_bps_panda-29.2025.4500}/PKG-INFO

@@ -1,18 +1,18 @@
 Metadata-Version: 2.4
 Name: lsst-ctrl-bps-panda
-Version: 29.2025.4300
+Version: 29.2025.4500
 Summary: PanDA plugin for lsst-ctrl-bps.
 Author-email: Rubin Observatory Data Management <dm-admin@lists.lsst.org>
-License: BSD 3-Clause License
+License-Expression: BSD-3-Clause OR GPL-3.0-or-later
 Project-URL: Homepage, https://github.com/lsst/ctrl_bps_panda
 Keywords: lsst
 Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering :: Astronomy
 Requires-Python: >=3.11.0
 Description-Content-Type: text/x-rst

{lsst_ctrl_bps_panda-29.2025.4300 → lsst_ctrl_bps_panda-29.2025.4500}/pyproject.toml

@@ -6,19 +6,20 @@ build-backend = "setuptools.build_meta"
 name = "lsst-ctrl-bps-panda"
 requires-python = ">=3.11.0"
 description = "PanDA plugin for lsst-ctrl-bps."
-license = {text = "BSD 3-Clause License"}
+license = "BSD-3-Clause OR GPL-3.0-or-later"
+license-files = ["COPYRIGHT", "LICENSE", "bsd_license.txt", "gpl-v3.0.txt"]
 readme = "README.rst"
 authors = [
     {name="Rubin Observatory Data Management", email="dm-admin@lists.lsst.org"},
 ]
 classifiers = [
     "Intended Audience :: Science/Research",
-    "License :: OSI Approved :: BSD License",
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Topic :: Scientific/Engineering :: Astronomy",
 ]
 keywords = ["lsst"]
@@ -51,7 +52,6 @@ where = ["python"]
 
 [tool.setuptools]
 zip-safe = true
-license-files = ["COPYRIGHT", "LICENSE", "bsd_license.txt", "gpl-v3.0.txt"]
 
 [tool.setuptools.package-data]
 "lsst.ctrl.bps.panda" = ["conf_example/*.yaml"]

{lsst_ctrl_bps_panda-29.2025.4300 → lsst_ctrl_bps_panda-29.2025.4500}/python/lsst/ctrl/bps/panda/constants.py

@@ -42,3 +42,4 @@ PANDA_DEFAULT_MAX_COPY_WORKERS = 10
 PANDA_DEFAULT_MAX_PAYLOADS_PER_PANDA_JOB = 10
 PANDA_DEFAULT_ORDER_ID_MAP_FILE = "panda_order_id_map.json"
 PANDA_DEFAULT_NAME_LENGTH = 4000
+PANDA_DEFAULT_MAX_REQUEST_LENGTH = 400000000  # 400M

{lsst_ctrl_bps_panda-29.2025.4300 → lsst_ctrl_bps_panda-29.2025.4500}/python/lsst/ctrl/bps/panda/edgenode/build_cmd_line_decoder.py

@@ -15,8 +15,13 @@ import sys
 
 from lsst.ctrl.bps.constants import DEFAULT_MEM_FMT, DEFAULT_MEM_UNIT
 from lsst.ctrl.bps.drivers import prepare_driver
-from lsst.ctrl.bps.panda.constants import PANDA_DEFAULT_MAX_COPY_WORKERS
-from lsst.ctrl.bps.panda.utils import copy_files_for_distribution, download_extract_archive, get_idds_client
+from lsst.ctrl.bps.panda.constants import PANDA_DEFAULT_MAX_COPY_WORKERS, PANDA_DEFAULT_MAX_REQUEST_LENGTH
+from lsst.ctrl.bps.panda.utils import (
+    copy_files_for_distribution,
+    download_extract_archive,
+    get_idds_client,
+    get_idds_result,
+)
 from lsst.resources import ResourcePath
 from lsst.utils.timer import time_this
 
@@ -90,6 +95,23 @@ file_distribution_uri = ResourcePath(config["fileDistributionEndPoint"], forceDi
 copy_files_for_distribution(bps_workflow.files_to_pre_stage, file_distribution_uri, max_copy_workers)
 
 idds_client = get_idds_client(config)
+
+# split workflow into steps if the workflow is hughe
+_, max_request_length = config.search("maxRequestLength", opt={"default": PANDA_DEFAULT_MAX_REQUEST_LENGTH})
+workflow_steps = idds_workflow.split_workflow_to_steps(
+    request_cache=config["submitPath"], max_request_length=max_request_length
+)
+print(f"workflow_steps: {workflow_steps}")
+for wf_step in workflow_steps:
+    ret_step = idds_client.submit(wf_step, username=None, use_dataset_name=False)
+    status, result_step, error = get_idds_result(ret_step)
+    if status and result_step == 0:
+        msg = f"iDDS client manager successfully uploaded workflow step: {wf_step.step_name}"
+        print(msg)
+    else:
+        msg = f"iDDS client manager failed to submit workflow step {wf_step.step_name}: {ret_step}"
+        raise RuntimeError(msg)
+
 ret = idds_client.update_build_request(request_id, signature, idds_workflow)
 print(f"update_build_request returns: {ret}")
 sys.exit(ret[0])

{lsst_ctrl_bps_panda-29.2025.4300 → lsst_ctrl_bps_panda-29.2025.4500}/python/lsst/ctrl/bps/panda/panda_service.py

@@ -45,14 +45,20 @@ from lsst.ctrl.bps import (
     WmsRunReport,
     WmsStates,
 )
-from lsst.ctrl.bps.panda.constants import PANDA_DEFAULT_MAX_COPY_WORKERS
+from lsst.ctrl.bps.panda.constants import (
+    PANDA_DEFAULT_MAX_COPY_WORKERS,
+    PANDA_DEFAULT_MAX_REQUEST_LENGTH,
+)
 from lsst.ctrl.bps.panda.utils import (
     add_final_idds_work,
     add_idds_work,
+    aggregate_by_basename,
     copy_files_for_distribution,
     create_idds_build_workflow,
+    extract_taskname,
     get_idds_client,
     get_idds_result,
+    idds_call_with_check,
 )
 from lsst.resources import ResourcePath
 from lsst.utils.timer import time_this
@@ -108,6 +114,9 @@ class PanDAService(BaseWmsService):
             return idds_build_workflow
 
         else:
+            _, max_request_length = self.config.search(
+                "maxRequestLength", opt={"default": PANDA_DEFAULT_MAX_REQUEST_LENGTH}
+            )
             _, max_copy_workers = self.config.search(
                 "maxCopyWorkers", opt={"default": PANDA_DEFAULT_MAX_COPY_WORKERS}
             )
@@ -119,6 +128,7 @@ class PanDAService(BaseWmsService):
             if not protocol_pattern.match(file_distribution_uri):
                 file_distribution_uri = "file://" + file_distribution_uri
 
+            idds_client = get_idds_client(self.config)
             submit_cmd = workflow.run_attrs.get("bps_iscustom", False)
             if not submit_cmd:
                 copy_files_for_distribution(
@@ -127,7 +137,23 @@ class PanDAService(BaseWmsService):
                     max_copy_workers,
                 )
 
-            idds_client = get_idds_client(self.config)
+                idds_wf = workflow.idds_client_workflow
+                workflow_steps = idds_wf.split_workflow_to_steps(
+                    request_cache=self.config["submitPath"], max_request_length=max_request_length
+                )
+                for wf_step in workflow_steps:
+                    ret_step = idds_client.submit(wf_step, username=None, use_dataset_name=False)
+                    status, result_step, error = get_idds_result(ret_step)
+                    if status and result_step == 0:
+                        msg = f"iDDS client manager successfully uploaded workflow step: {wf_step.step_name}"
+                        _LOG.info(msg)
+                    else:
+                        msg = (
+                            f"iDDS client manager failed to submit workflow step {wf_step.step_name}: "
+                            f"{ret_step}"
+                        )
+                        raise RuntimeError(msg)
+
             ret = idds_client.submit(workflow.idds_client_workflow, username=None, use_dataset_name=False)
             _LOG.debug("iDDS client manager submit returned = %s", ret)
 
@@ -172,154 +198,177 @@ class PanDAService(BaseWmsService):
             return run_reports, message
 
         idds_client = get_idds_client(self.config)
-        ret = idds_client.get_requests(request_id=wms_workflow_id, with_detail=True)
-        _LOG.debug("PanDA get workflow status returned = %s", str(ret))
-
-        request_status = ret[0]
-        if request_status != 0:
-            raise RuntimeError(f"Error to get workflow status: {ret} for id: {wms_workflow_id}")
+        ret = idds_call_with_check(
+            idds_client.get_requests,
+            func_name="get workflow status",
+            request_id=wms_workflow_id,
+            with_detail=True,
+        )
 
         tasks = ret[1][1]
         if not tasks:
             message = f"No records found for workflow id '{wms_workflow_id}'. Hint: double check the id"
-        else:
-            head = tasks[0]
-            wms_report = WmsRunReport(
-                wms_id=str(head["request_id"]),
-                operator=head["username"],
-                project="",
-                campaign="",
-                payload="",
-                run=head["name"],
-                state=WmsStates.UNKNOWN,
-                total_number_jobs=0,
-                job_state_counts=dict.fromkeys(WmsStates, 0),
-                job_summary={},
-                run_summary="",
-                exit_code_summary=[],
-            )
+            return run_reports, message
 
-            # The status of a task is taken from the first item of state_map.
-            # The workflow is in status WmsStates.FAILED when:
-            #      All tasks have failed.
-            # SubFinished tasks has jobs in
-            #      output_processed_files: Finished
-            #      output_failed_files: Failed
-            #      output_missing_files: Missing
-            state_map = {
-                "Finished": [WmsStates.SUCCEEDED],
-                "SubFinished": [
-                    WmsStates.SUCCEEDED,
-                    WmsStates.FAILED,
-                    WmsStates.PRUNED,
-                ],
-                "Transforming": [
-                    WmsStates.RUNNING,
-                    WmsStates.SUCCEEDED,
-                    WmsStates.FAILED,
-                    WmsStates.UNREADY,
-                    WmsStates.PRUNED,
-                ],
-                "Failed": [WmsStates.FAILED, WmsStates.PRUNED],
-            }
-
-            file_map = {
-                WmsStates.SUCCEEDED: "output_processed_files",
-                WmsStates.RUNNING: "output_processing_files",
-                WmsStates.FAILED: "output_failed_files",
-                WmsStates.UNREADY: "input_new_files",
-                WmsStates.PRUNED: "output_missing_files",
-            }
-
-            workflow_status = head["status"]["attributes"]["_name_"]
-            if workflow_status in ["Finished", "SubFinished"]:
-                wms_report.state = WmsStates.SUCCEEDED
-            elif workflow_status in ["Failed", "Expired"]:
-                wms_report.state = WmsStates.FAILED
-            elif workflow_status in ["Cancelled"]:
-                wms_report.state = WmsStates.DELETED
-            elif workflow_status in ["Suspended"]:
-                wms_report.state = WmsStates.HELD
-            else:
-                wms_report.state = WmsStates.RUNNING
-
-            try:
-                tasks.sort(key=lambda x: x["transform_workload_id"])
-            except Exception:
-                tasks.sort(key=lambda x: x["transform_id"])
-
-            exit_codes_all = {}
-            # Loop over all tasks data returned by idds_client
-            for task in tasks:
-                if task["transform_id"] is None:
-                    # Not created task (It happens because of an outer join
-                    # between requests table and transforms table).
-                    continue
-
-                exit_codes = []
-                totaljobs = task["output_total_files"]
-                wms_report.total_number_jobs += totaljobs
-                tasklabel = task["transform_name"]
-                tasklabel = re.sub(wms_report.run + "_", "", tasklabel)
-                status = task["transform_status"]["attributes"]["_name_"]
-                taskstatus = {}
-                # if the state is failed, gather exit code information
-                if status in ["SubFinished", "Failed"]:
-                    transform_workload_id = task["transform_workload_id"]
-                    if not (task["transform_name"] and task["transform_name"].startswith("build_task")):
-                        new_ret = idds_client.get_contents_output_ext(
-                            request_id=wms_workflow_id, workload_id=transform_workload_id
-                        )
-                        _LOG.debug(
-                            "PanDA get task %s detail returned = %s", transform_workload_id, str(new_ret)
-                        )
+        # Create initial WmsRunReport
+        head = tasks[0]
+        wms_report = WmsRunReport(
+            wms_id=str(head["request_id"]),
+            operator=head["username"],
+            project="",
+            campaign="",
+            payload="",
+            run=head["name"],
+            state=WmsStates.UNKNOWN,
+            total_number_jobs=0,
+            job_state_counts=dict.fromkeys(WmsStates, 0),
+            job_summary={},
+            run_summary="",
+            exit_code_summary={},
+        )
 
-                        request_status = new_ret[0]
-                        if request_status != 0:
-                            raise RuntimeError(
-                                f"Error to get workflow status: {new_ret} for id: {wms_workflow_id}"
-                            )
+        # Define workflow status mapping
+        workflow_status = head["status"]["attributes"]["_name_"]
+        if workflow_status in ("Finished", "SubFinished"):
+            wms_report.state = WmsStates.SUCCEEDED
+        elif workflow_status in ("Failed", "Expired"):
+            wms_report.state = WmsStates.FAILED
+        elif workflow_status == "Cancelled":
+            wms_report.state = WmsStates.DELETED
+        elif workflow_status == "Suspended":
+            wms_report.state = WmsStates.HELD
+        else:
+            wms_report.state = WmsStates.RUNNING
+
+        # Define state mapping for job aggregation
+        # The status of a task is taken from the first item of state_map.
+        # The workflow is in status WmsStates.FAILED when:
+        #      All tasks have failed.
+        # SubFinished tasks has jobs in
+        #      output_processed_files: Finished
+        #      output_failed_files: Failed
+        #      output_missing_files: Missing
+        state_map = {
+            "Finished": [WmsStates.SUCCEEDED],
+            "SubFinished": [WmsStates.SUCCEEDED, WmsStates.FAILED, WmsStates.PRUNED],
+            "Transforming": [
+                WmsStates.RUNNING,
+                WmsStates.SUCCEEDED,
+                WmsStates.FAILED,
+                # WmsStates.READY,
+                WmsStates.UNREADY,
+                WmsStates.PRUNED,
+            ],
+            "Failed": [WmsStates.FAILED, WmsStates.PRUNED],
+        }
+
+        file_map = {
+            WmsStates.SUCCEEDED: "output_processed_files",
+            WmsStates.RUNNING: "output_processing_files",
+            WmsStates.FAILED: "output_failed_files",
+            # WmsStates.READY: "output_activated_files",
+            WmsStates.UNREADY: "input_new_files",
+            WmsStates.PRUNED: "output_missing_files",
+        }
+
+        # Sort tasks by workload_id or fallback
+        try:
+            tasks.sort(key=lambda x: x["transform_workload_id"])
+        except (KeyError, TypeError):
+            tasks.sort(key=lambda x: x["transform_id"])
+
+        exit_codes_all = {}
+
+        # --- Process each task sequentially ---
+        for task in tasks:
+            if task.get("transform_id") is None:
+                # Not created task (It happens because of an outer join
+                # between requests table and transforms table).
+                continue
+
+            task_name = task.get("transform_name", "")
+            tasklabel = extract_taskname(task_name)
+            status = task["transform_status"]["attributes"]["_name_"]
+            totaljobs = task.get("output_total_files", 0)
+            wms_report.total_number_jobs += totaljobs
+
+            # --- If task failed/subfinished, fetch exit codes ---
+            if status in ("SubFinished", "Failed") and not task_name.startswith("build_task"):
+                transform_workload_id = task.get("transform_workload_id")
+                if transform_workload_id:
+                    # When there are failed jobs, ctrl_bps check
+                    # the number of exit codes
+                    nfailed = task.get("output_failed_files", 0)
+                    exit_codes_all[tasklabel] = [1] * nfailed
+                    if return_exit_codes:
+                        new_ret = idds_call_with_check(
+                            idds_client.get_contents_output_ext,
+                            func_name=f"get task {transform_workload_id} detail",
+                            request_id=wms_workflow_id,
+                            workload_id=transform_workload_id,
+                        )
                         # task_info is a dictionary of len 1 that contains
                         # a list of dicts containing panda job info
                         task_info = new_ret[1][1]
-
                         if len(task_info) == 1:
-                            wmskey = list(task_info.keys())[0]
-                            wmsjobs = task_info[wmskey]
+                            _, wmsjobs = next(iter(task_info.items()))
+                            exit_codes_all[tasklabel] = [
+                                j["trans_exit_code"]
+                                for j in wmsjobs
+                                if j.get("trans_exit_code") not in (None, 0, "0")
+                            ]
+                            if nfailed > 0 and len(exit_codes_all[tasklabel]) == 0:
+                                _LOG.debug(
+                                    f"No exit codes in iDDS task info for workload {transform_workload_id}"
+                                )
                         else:
-                            err_msg = "Unexpected job return from PanDA: "
-                            err_msg += f"{task_info} for id: {transform_workload_id}"
-                            raise RuntimeError(err_msg)
-                        exit_codes = [
-                            wmsjob["trans_exit_code"]
-                            for wmsjob in wmsjobs
-                            if wmsjob["trans_exit_code"] is not None and int(wmsjob["trans_exit_code"]) != 0
-                        ]
-                        exit_codes_all[tasklabel] = exit_codes
-                # Fill number of jobs in all WmsStates
-                for state in WmsStates:
-                    njobs = 0
-                    # Each WmsState have many iDDS status mapped to it.
-                    if status in state_map:
-                        for mappedstate in state_map[status]:
-                            if state in file_map and mappedstate == state:
-                                if task[file_map[mappedstate]] is not None:
-                                    njobs = task[file_map[mappedstate]]
-                                if state == WmsStates.RUNNING:
-                                    njobs += task["output_new_files"] - task["input_new_files"]
-                                break
-                    wms_report.job_state_counts[state] += njobs
-                    taskstatus[state] = njobs
-                wms_report.job_summary[tasklabel] = taskstatus
+                            raise RuntimeError(
+                                f"Unexpected iDDS task info for workload {transform_workload_id}: {task_info}"
+                            )
 
-                # To fill the EXPECTED column
-                if wms_report.run_summary:
-                    wms_report.run_summary += ";"
-                wms_report.run_summary += f"{tasklabel}:{totaljobs}"
+            # --- Aggregate job states ---
+            taskstatus = {}
+            mapped_states = state_map.get(status, [])
+            for state in WmsStates:
+                njobs = 0
+                if state in mapped_states and state in file_map:
+                    val = task.get(file_map[state])
+                    if val:
+                        njobs = val
+                    if state == WmsStates.RUNNING:
+                        njobs += task.get("output_new_files", 0) - task.get("input_new_files", 0)
+                if state != WmsStates.UNREADY:
+                    wms_report.job_state_counts[state] += njobs
+                taskstatus[state] = njobs
 
-            wms_report.exit_code_summary = exit_codes_all
-            run_reports.append(wms_report)
+            # Count UNREADY
+            unready = WmsStates.UNREADY
+            taskstatus[unready] = totaljobs - sum(
+                taskstatus[state] for state in WmsStates if state != unready
+            )
+            wms_report.job_state_counts[unready] += taskstatus[unready]
+
+            # Store task summary
+            wms_report.job_summary[tasklabel] = taskstatus
+            summary_part = f"{tasklabel}:{totaljobs}"
+            if wms_report.run_summary:
+                summary_part = f";{summary_part}"
+            wms_report.run_summary += summary_part
+
+        # Store all exit codes
+        wms_report.exit_code_summary = exit_codes_all
+
+        (
+            wms_report.job_summary,
+            wms_report.exit_code_summary,
+            wms_report.run_summary,
+        ) = aggregate_by_basename(
+            wms_report.job_summary,
+            wms_report.exit_code_summary,
+            wms_report.run_summary,
+        )
 
+        run_reports.append(wms_report)
         return run_reports, message
 
     def list_submitted_jobs(self, wms_id=None, user=None, require_bps=True, pass_thru=None, is_global=False):

{lsst_ctrl_bps_panda-29.2025.4300 → lsst_ctrl_bps_panda-29.2025.4500}/python/lsst/ctrl/bps/panda/utils.py

@@ -29,10 +29,13 @@
 
 __all__ = [
     "add_decoder_prefix",
+    "aggregate_by_basename",
     "convert_exec_string_to_hex",
     "copy_files_for_distribution",
+    "extract_taskname",
     "get_idds_client",
     "get_idds_result",
+    "idds_call_with_check",
 ]
 
 import binascii
@@ -41,6 +44,7 @@ import json
 import logging
 import os
 import random
+import re
 import tarfile
 import time
 import uuid
@@ -51,7 +55,7 @@ from idds.doma.workflowv2.domapandawork import DomaPanDAWork
 from idds.workflowv2.workflow import AndCondition
 from idds.workflowv2.workflow import Workflow as IDDS_client_workflow
 
-from lsst.ctrl.bps import BpsConfig, GenericWorkflow, GenericWorkflowJob
+from lsst.ctrl.bps import BpsConfig, GenericWorkflow, GenericWorkflowJob, WmsStates
 from lsst.ctrl.bps.panda.cmd_line_embedder import CommandLineEmbedder
 from lsst.ctrl.bps.panda.constants import (
     PANDA_DEFAULT_CLOUD,
@@ -75,6 +79,98 @@ from lsst.resources import ResourcePath
 _LOG = logging.getLogger(__name__)
 
 
+def extract_taskname(s: str) -> str:
+    """Extract the task name from a string that follows a pattern
+    CampaignName_timestamp_TaskNumber_TaskLabel_ChunkNumber.
+
+    Parameters
+    ----------
+    s : `str`
+        The input string from which to extract the task name.
+
+    Returns
+    -------
+    taskname : `str`
+        The extracted task name as per the rules above.
+    """
+    # remove surrounding quotes/spaces if present
+    s = s.strip().strip("'\"")
+
+    # find all occurrences of underscore + digits + underscore,
+    # take the last one
+    matches = re.findall(r"_(\d+)_", s)
+    if matches:
+        last_number = matches[-1]
+        last_pos = s.rfind(f"_{last_number}_") + len(f"_{last_number}_")
+        taskname = s[last_pos:]
+        return taskname
+
+    # fallback: if no such pattern, return everything
+    taskname = s
+    return taskname
+
+
+def aggregate_by_basename(job_summary, exit_code_summary, run_summary):
+    """Aggregate job exit code and run summaries by
+    their base label (basename).
+
+    Parameters
+    ----------
+    job_summary : `dict` [`str`, `dict` [`str`, `int`]]
+        A mapping of job labels to state-count mappings.
+    exit_code_summary : `dict` [`str`, `list` [`int`]]
+        A mapping of job labels to lists of exit codes.
+    run_summary : `str`
+        A semicolon-separated string of job summaries
+        where each entry has the format "<label>:<count>".
+
+    Returns
+    -------
+    aggregated_jobs : `dict` [`str`, `dict` [`str`, `int`]]
+        A dictionary mapping each base label to the summed job state counts
+        across all matching labels.
+    aggregated_exits : `dict` [`str`, `list` [`int`]]
+        A dictionary mapping each base label to a combined list of exit codes
+        from all matching labels.
+    aggregated_run : `str`
+        A semicolon-separated string with aggregated job counts by base label.
+    """
+
+    def base_label(label):
+        return re.sub(r"_\d+$", "", label)
+
+    aggregated_jobs = {}
+    aggregated_exits = {}
+
+    for label, states in job_summary.items():
+        base = base_label(label)
+        if base not in aggregated_jobs:
+            aggregated_jobs[base] = dict.fromkeys(WmsStates, 0)
+        for state, count in states.items():
+            aggregated_jobs[base][state] += count
+
+    for label, codes in exit_code_summary.items():
+        base = base_label(label)
+        aggregated_exits.setdefault(base, []).extend(codes)
+
+    aggregated = {}
+    for entry in run_summary.split(";"):
+        entry = entry.strip()
+        if not entry:
+            continue
+        try:
+            label, num = entry.split(":")
+            num = int(num)
+        except ValueError:
+            continue
+
+        base = base_label(label)
+        aggregated[base] = aggregated.get(base, 0) + num
+
+    aggregated_run = ";".join(f"{base}:{count}" for base, count in aggregated.items())
+    return aggregated_jobs, aggregated_exits, aggregated_run
+
+
 def copy_files_for_distribution(files_to_stage, file_distribution_uri, max_copy_workers):
     """Brings locally generated files into Cloud for further
     utilization them on the edge nodes.
@@ -193,6 +289,40 @@ def get_idds_result(ret):
     return status, result, error
 
 
+def idds_call_with_check(func, *, func_name: str, request_id: int, **kwargs):
+    """Call an iDDS client function, log, and check the return code.
+
+    Parameters
+    ----------
+    func : callable
+        The iDDS client function to call.
+    func_name : `str`
+        Name used for logging.
+    request_id : `int`
+        The request or workflow ID.
+    **kwargs
+        Additional keyword arguments passed to the function.
+
+    Returns
+    -------
+    ret : `Any`
+        The return value from the iDDS client function.
+    """
+    call_kwargs = dict(kwargs)
+    if request_id is not None:
+        call_kwargs["request_id"] = request_id
+
+    ret = func(**call_kwargs)
+
+    _LOG.debug("PanDA %s returned = %s", func_name, str(ret))
+
+    request_status = ret[0]
+    if request_status != 0:
+        raise RuntimeError(f"Error calling {func_name}: {ret} for id: {request_id}")
+
+    return ret
+
+
 def _make_pseudo_filename(config, gwjob):
     """Make the job pseudo filename.
 

lsst_ctrl_bps_panda-29.2025.4500/python/lsst/ctrl/bps/panda/version.py

@@ -0,0 +1,2 @@
+__all__ = ["__version__"]
+__version__ = "29.2025.4500"

{lsst_ctrl_bps_panda-29.2025.4300 → lsst_ctrl_bps_panda-29.2025.4500/python/lsst_ctrl_bps_panda.egg-info}/PKG-INFO

@@ -1,18 +1,18 @@
 Metadata-Version: 2.4
 Name: lsst-ctrl-bps-panda
-Version: 29.2025.4300
+Version: 29.2025.4500
 Summary: PanDA plugin for lsst-ctrl-bps.
 Author-email: Rubin Observatory Data Management <dm-admin@lists.lsst.org>
-License: BSD 3-Clause License
+License-Expression: BSD-3-Clause OR GPL-3.0-or-later
 Project-URL: Homepage, https://github.com/lsst/ctrl_bps_panda
 Keywords: lsst
 Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering :: Astronomy
 Requires-Python: >=3.11.0
 Description-Content-Type: text/x-rst

lsst_ctrl_bps_panda-29.2025.4300/python/lsst/ctrl/bps/panda/version.py

@@ -1,2 +0,0 @@
-__all__ = ["__version__"]
-__version__ = "29.2025.4300"