lsst-ctrl-bps 29.2025.3700__tar.gz → 29.2025.3900__tar.gz

{lsst_ctrl_bps-29.2025.3700/python/lsst_ctrl_bps.egg-info → lsst_ctrl_bps-29.2025.3900}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-ctrl-bps
-Version: 29.2025.3700
+Version: 29.2025.3900
 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.3700 → lsst_ctrl_bps-29.2025.3900}/python/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-29.2025.3700 → lsst_ctrl_bps-29.2025.3900}/python/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-29.2025.3900/python/lsst/ctrl/bps/version.py

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

{lsst_ctrl_bps-29.2025.3700 → lsst_ctrl_bps-29.2025.3900/python/lsst_ctrl_bps.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-ctrl-bps
-Version: 29.2025.3700
+Version: 29.2025.3900
 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.3700 → lsst_ctrl_bps-29.2025.3900}/python/lsst_ctrl_bps.egg-info/SOURCES.txt

@@ -53,6 +53,7 @@ python/lsst_ctrl_bps.egg-info/entry_points.txt
 python/lsst_ctrl_bps.egg-info/requires.txt
 python/lsst_ctrl_bps.egg-info/top_level.txt
 python/lsst_ctrl_bps.egg-info/zip-safe
+tests/test_bps_reports.py
 tests/test_bps_utils.py
 tests/test_bpsconfig.py
 tests/test_cli_commands.py

lsst_ctrl_bps-29.2025.3700/tests/test_report.py → lsst_ctrl_bps-29.2025.3900/tests/test_bps_reports.py

@@ -42,9 +42,9 @@ from lsst.ctrl.bps import (
     WmsJobReport,
     WmsRunReport,
     WmsStates,
+    compile_code_summary,
     compile_job_summary,
 )
-from lsst.ctrl.bps.report import retrieve_report
 
 
 class FakeRunReport(BaseRunReport):
@@ -335,23 +335,30 @@ class ExitCodesReportTestCase(unittest.TestCase):
 
         self.actual = ExitCodesReport(self.fields)
 
-    def testAddWithJobSummary(self):
-        """Test adding a run with a job summary."""
-        self.run.jobs = None
+    def testAddSuccess(self):
+        """Test adding a run successfully."""
         self.actual.add(self.run)
+
+        self.assertEqual(len(self.actual), 2)
         self.assertEqual(self.actual, self.expected)
 
-    def testAddWithJobs(self):
-        """Test adding a run with a job info, but not job summary."""
-        self.run.job_summary = None
+    def testAddFailure(self):
+        """Test adding a run unsuccessfully."""
+        self.run.job_summary = {}
+        self.run.exit_code_summary = {}
+
         self.actual.add(self.run)
-        self.assertEqual(self.actual, self.expected)
+
+        self.assertEqual(len(self.actual), 0)
+        self.assertRegex(self.actual.message, r"^WARNING.*report.*incomplete")
 
     def testAddWithoutRunSummary(self):
         """Test adding a run without a run summary."""
         self.run.run_summary = None
+
         self.actual.add(self.run)
-        self.assertRegex(self.actual.message, r"^WARNING.*incomplete")
+
+        self.assertRegex(self.actual.message, r"^WARNING.*sorted alphabetically")
 
 
 class CompileJobSummaryTestCase(unittest.TestCase):
@@ -364,57 +371,129 @@ class CompileJobSummaryTestCase(unittest.TestCase):
         pass
 
     def testSummaryExists(self):
-        """Test if existing report is not altered."""
+        """Test if the existing report is not altered."""
         # Create a report with a "fake" job summary, i.e., a summary which
         # differs from the one which would be compiled from the information
         # about individual jobs.
-        expected = dataclasses.replace(self.report)
-        expected.job_summary = {"foo": {state: 1 if state == WmsStates.FAILED else 0 for state in WmsStates}}
-
+        expected = dataclasses.replace(
+            self.report,
+            job_summary={"foo": {state: 1 if state == WmsStates.FAILED else 0 for state in WmsStates}},
+        )
         result = dataclasses.replace(expected)
-        compile_job_summary(result)
+
+        messages = compile_job_summary(result)
+
         self.assertEqual(result, expected)
+        self.assertFalse(messages)
 
     def testSummaryMissing(self):
-        """Test if the summary will be compiled if necessary."""
-        result = dataclasses.replace(self.report)
-        result.job_summary = None
-        compile_job_summary(result)
+        """Test if the summary is compiled if necessary."""
+        result = dataclasses.replace(self.report, job_summary=None)
+
+        messages = compile_job_summary(result)
+
         self.assertEqual(result, self.report)
+        self.assertFalse(messages)
 
     def testCompilationError(self):
-        """Test if error is raised if the summary cannot be compiled."""
-        self.report.job_summary = None
-        self.report.jobs = None
-        with self.assertRaises(ValueError):
-            compile_job_summary(self.report)
+        """Test if a warning is issued if the summary cannot be compiled."""
+        result = dataclasses.replace(self.report, jobs=None, job_summary=None)
+
+        messages = compile_job_summary(result)
+
+        self.assertEqual(len(messages), 1)
+        self.assertRegex(messages[0], r"information.*not available")
 
 
-class RetrieveReportTestCase(unittest.TestCase):
-    """Test report retrieval."""
+class CompileCodeSummaryTestCase(unittest.TestCase):
+    """Test compiling a code summary."""
 
     def setUp(self):
-        self.report = dataclasses.replace(TEST_REPORT)
+        self.report = WmsRunReport(
+            wms_id="1.0",
+            global_wms_id="foo#1.0",
+            path="/path/to/run",
+            label="label",
+            run="run",
+            project="dev",
+            campaign="testing",
+            payload="test",
+            operator="tester",
+            run_summary="foo:1;bar:1;baz:1",
+            state=WmsStates.RUNNING,
+            jobs=[
+                WmsJobReport(wms_id="1.0", name="", label="foo", state=WmsStates.SUCCEEDED),
+                WmsJobReport(wms_id="2.0", name="", label="bar", state=WmsStates.FAILED),
+                WmsJobReport(wms_id="3.0", name="", label="baz", state=WmsStates.RUNNING),
+            ],
+            total_number_jobs=3,
+            job_state_counts={
+                state: 1 if state in {WmsStates.SUCCEEDED, WmsStates.FAILED, WmsStates.RUNNING} else 0
+                for state in WmsStates
+            },
+            job_summary={
+                "foo": {state: 1 if state == WmsStates.SUCCEEDED else 0 for state in WmsStates},
+                "bar": {state: 1 if state == WmsStates.FAILED else 0 for state in WmsStates},
+                "baz": {state: 1 if state == WmsStates.RUNNING else 0 for state in WmsStates},
+            },
+            exit_code_summary={"foo": [], "bar": [1], "baz": []},
+        )
 
     def tearDown(self):
         pass
 
-    def testRetrievalPostprocessingSuccessful(self):
-        """Test retrieving a report successfully."""
-        reports, messages = retrieve_report(
-            "wms_test_utils.WmsServiceSuccess", run_id="1.0", postprocessors=(compile_job_summary,)
-        )
-        self.assertEqual(len(reports), 1)
-        self.assertEqual(reports[0], self.report)
+    def testAddingMissingEntries(self):
+        """Test if the missing entries are added to the summary."""
+        result = dataclasses.replace(self.report, exit_code_summary={"bar": [1]})
+
+        messages = compile_code_summary(result)
+
+        self.assertEqual(result, self.report)
         self.assertFalse(messages)
 
-    def testRetrievalPostprocessingFailed(self):
-        """Test failing to retrieve a report."""
-        report, messages = retrieve_report(
-            "wms_test_utils.WmsServiceFailure", postprocessors=(compile_job_summary,)
-        )
+    def testDetectingMismatches(self):
+        """Test if a mismatch between exit codes and failures is reported."""
+        expected = dataclasses.replace(self.report, exit_code_summary={"foo": [1], "bar": [1], "baz": []})
+        result = dataclasses.replace(expected)
+
+        messages = compile_code_summary(result)
+
+        self.assertEqual(result, expected)
         self.assertEqual(len(messages), 1)
-        self.assertRegex(messages[0], "Postprocessing error")
+        self.assertRegex(messages[0], r"exit codes.*differs.*failures.*labels: foo")
+
+    def testDetectingOmissions(self):
+        """Test if a failure not reflected in exit codes is reported."""
+        expected = dataclasses.replace(self.report, exit_code_summary={"foo": [], "baz": []})
+        result = dataclasses.replace(expected)
+
+        messages = compile_code_summary(result)
+
+        self.assertEqual(result, expected)
+        self.assertEqual(len(messages), 1)
+        self.assertRegex(messages[0], r"exit codes.*not available.*labels: bar")
+
+    def testDetectingDiscrepancies(self):
+        """Test if multiple discrepancies are reported."""
+        expected = dataclasses.replace(self.report, exit_code_summary={"foo": [], "baz": [1]})
+        result = dataclasses.replace(expected)
+
+        messages = compile_code_summary(result)
+
+        self.assertEqual(result, expected)
+        self.assertEqual(len(messages), 2)
+        self.assertRegex(messages[0], r"exit codes.*differs.*failures.*labels: baz")
+        self.assertRegex(messages[1], r"exit codes.*not available.*labels: bar")
+
+    def testHandlingNoJobSummary(self):
+        """Test if the existing report is not altered if no job summary."""
+        expected = dataclasses.replace(self.report, job_summary=None)
+        result = dataclasses.replace(expected)
+
+        messages = compile_code_summary(result)
+
+        self.assertEqual(result, expected)
+        self.assertFalse(messages)
 
 
 if __name__ == "__main__":

lsst_ctrl_bps-29.2025.3900/tests/test_report.py

@@ -0,0 +1,72 @@
+# This file is part of ctrl_bps.
+#
+# Developed for the LSST Data Management System.
+# This product includes software developed by the LSST Project
+# (https://www.lsst.org).
+# See the COPYRIGHT file at the top-level directory of this distribution
+# for details of code ownership.
+#
+# This software is dual licensed under the GNU General Public License and also
+# under a 3-clause BSD license. Recipients may choose which of these licenses
+# to use; please see the files gpl-3.0.txt and/or bsd_license.txt,
+# respectively.  If you choose the GPL option then the following text applies
+# (but note that there is still no warranty even if you opt for BSD instead):
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+"""Tests for reporting mechanism."""
+
+import dataclasses
+import unittest
+
+from wms_test_utils import TEST_REPORT
+
+from lsst.ctrl.bps import compile_job_summary
+from lsst.ctrl.bps.report import retrieve_report
+
+
+class RetrieveReportTestCase(unittest.TestCase):
+    """Test report retrieval."""
+
+    def setUp(self):
+        self.report = dataclasses.replace(TEST_REPORT)
+
+    def tearDown(self):
+        pass
+
+    def testRetrievalPostprocessingSuccessful(self):
+        """Test retrieving a report successfully."""
+        reports, messages = retrieve_report(
+            "wms_test_utils.WmsServiceSuccess", run_id="1.0", postprocessors=(compile_job_summary,)
+        )
+        self.assertEqual(len(reports), 1)
+        self.assertEqual(reports[0], self.report)
+        self.assertFalse(messages)
+
+    def testRetrievalPostprocessingFailed(self):
+        """Test failing to retrieve a report."""
+        report, messages = retrieve_report(
+            "wms_test_utils.WmsServiceFailure", postprocessors=(compile_job_summary,)
+        )
+        self.assertEqual(len(messages), 1)
+        self.assertRegex(messages[0], "issue.*postprocessing")
+
+    def testRetrievalInvalidClass(self):
+        """Test retrieving a report with an invalid class."""
+        with self.assertRaises(TypeError):
+            retrieve_report("wms_test_utils.WmsServiceInvalid", run_id="1.0", postprocessors=None)
+
+
+if __name__ == "__main__":
+    unittest.main()

lsst_ctrl_bps-29.2025.3700/python/lsst/ctrl/bps/version.py

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