dkist-processing-common 14.0.1__tar.gz → 14.0.2__tar.gz

{dkist_processing_common-14.0.1 → dkist_processing_common-14.0.2}/CHANGELOG.rst

@@ -1,3 +1,13 @@
+v14.0.2 (2026-05-04)
+====================
+
+Features
+--------
+
+- Convert TASK_TYPES quality metric to the new methodology. (`#332 <https://bitbucket.org/dkistdc/dkist-processing-common/pull-requests/332>`__)
+- Add `TaskCount` quality metric model. (`#332 <https://bitbucket.org/dkistdc/dkist-processing-common/pull-requests/332>`__)
+
+
 v14.0.1 (2026-04-22)
 ====================
 

{dkist_processing_common-14.0.1 → dkist_processing_common-14.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dkist-processing-common
-Version: 14.0.1
+Version: 14.0.2
 Summary: Common task classes used by the DKIST science data processing pipelines
 Author-email: NSO / AURA <dkistdc@nso.edu>
 License: BSD-3-Clause

{dkist_processing_common-14.0.1 → dkist_processing_common-14.0.2}/dkist_processing_common/models/quality.py

@@ -10,6 +10,7 @@ from pydantic import ConfigDict
 from pydantic import Field
 from pydantic import FiniteFloat
 from pydantic import PlainSerializer
+from pydantic import StringConstraints
 from pydantic import field_validator
 from pydantic import model_serializer
 from pydantic import model_validator
@@ -348,3 +349,23 @@ class QualityMetric(QualityModel):
     raincloud_data: list[RaincloudData] | None = None
     efficiency_data: list[EfficiencyData] | None = None
     warnings: list[str] | None = None
+
+
+###########################################################
+# Internal Quality Models                                 #
+#                                                         #
+# Shared models used for generating quality metrics,      #
+#  but not part of the dkist-quality interface            #
+###########################################################
+
+
+class TaskCount(BaseModel):
+    """Frame counts for a single IP task type."""
+
+    task_type: Annotated[str, StringConstraints(to_upper=True)]
+    total_frames: int
+    frames_not_used: int = 0
+
+    def as_tuple(self) -> tuple[str, str, str]:
+        """Render as a tuple."""
+        return self.task_type, str(self.total_frames), str(self.frames_not_used)

{dkist_processing_common-14.0.1 → dkist_processing_common-14.0.2}/dkist_processing_common/tasks/l1_output_data.py

@@ -6,12 +6,16 @@ from pathlib import Path
 from typing import Iterable
 
 from dkist_processing_common.codecs.basemodel import basemodel_decoder
+from dkist_processing_common.codecs.basemodel import basemodel_encoder
 from dkist_processing_common.codecs.quality import quality_data_encoder
 from dkist_processing_common.models.message import CatalogFrameMessage
 from dkist_processing_common.models.message import CatalogFrameMessageBody
 from dkist_processing_common.models.message import CatalogObjectMessage
 from dkist_processing_common.models.message import CatalogObjectMessageBody
+from dkist_processing_common.models.metric_code import MetricCode
 from dkist_processing_common.models.quality import QualityMetric
+from dkist_processing_common.models.quality import TableData
+from dkist_processing_common.models.quality import TaskCount
 from dkist_processing_common.models.tags import Tag
 from dkist_processing_common.tasks.mixin.globus import GlobusMixin
 from dkist_processing_common.tasks.mixin.interservice_bus import InterserviceBusMixin
@@ -150,6 +154,7 @@ class AssembleQualityData(L1OutputDataBase, QualityMixin):
         """Run method for the task."""
         # this is the new way, which will eventually supplant the old `quality_assemble_data`
         with self.telemetry_span("Assembling generic quality data"):
+            self.compute_and_write_type_counts()
             quality_data = self.assemble_quality_data()
 
         # this is the old way, which is being replaced by the new `assemble_quality_data`
@@ -176,6 +181,54 @@ class AssembleQualityData(L1OutputDataBase, QualityMixin):
             metrics.append(metric.model_dump(mode="json"))
         return metrics
 
+    def compute_and_write_type_counts(self) -> None:
+        """Compute and write TASK_TYPES quality metric."""
+        # retrieve the intermediate TASK_TYPES data for each IP task
+        task_counts: list[TaskCount] = self.quality_read_intermediate_task_type_counts()
+
+        # don't write anything if there is no data
+        if not task_counts:
+            return
+
+        header = ("Task Type", "Total Frames", "Unused Frames")
+        rows = [header]
+
+        warning_count_threshold = 0.05
+        warnings = []
+        for task_count in task_counts:
+            # add the row
+            rows.append(task_count.as_tuple())
+            # determine if there are any warnings for this task type
+            if task_count.total_frames == 0:
+                warnings.append(f"NO {task_count.task_type} frames were used!")
+            elif (
+                frame_ratio := task_count.frames_not_used / task_count.total_frames
+            ) > warning_count_threshold:
+                warnings.append(
+                    f"{round(100 * frame_ratio, 1)}% of frames were not used in the "
+                    f"processing of task type {task_count.task_type}"
+                )
+        warnings = warnings or None
+
+        table_data = TableData(rows=tuple(rows))
+        metric = QualityMetric(
+            name="Frame Counts",
+            description="This metric is a count of the number of frames used to produce a "
+            "calibrated L1 dataset",
+            metric_code=MetricCode.task_types,
+            table_data=[table_data],
+            warnings=warnings,
+        )
+        self.write(metric, tags=Tag.quality("GENERIC"), encoder=basemodel_encoder)
+
+    def quality_read_intermediate_task_type_counts(self) -> list[TaskCount]:
+        """Read intermediate task type data."""
+        tags = Tag.quality(MetricCode.task_types)
+        task_counts: list[TaskCount] = list(
+            self.read(tags=tags, decoder=basemodel_decoder, model=TaskCount)
+        )
+        return task_counts
+
 
 class SubmitDatasetMetadata(L1OutputDataBase):
     """

{dkist_processing_common-14.0.1 → dkist_processing_common-14.0.2}/dkist_processing_common/tasks/mixin/quality/_base.py

@@ -2,21 +2,17 @@
 
 from typing import Iterable
 
-import numpy as np
-
 from dkist_processing_common.codecs.json import json_encoder
 from dkist_processing_common.codecs.quality import QualityValueEncoder
 from dkist_processing_common.models.tags import Tag
 from dkist_processing_common.models.task_name import TaskName
 from dkist_processing_common.tasks.mixin.quality._metrics import _PolcalQualityMixin
 from dkist_processing_common.tasks.mixin.quality._metrics import _SimplePlotQualityMixin
-from dkist_processing_common.tasks.mixin.quality._metrics import _TableQualityMixin
 from dkist_processing_common.tasks.mixin.quality._metrics import _WavecalQualityMixin
 
 
 class QualityMixin(
     _SimplePlotQualityMixin,
-    _TableQualityMixin,
     _PolcalQualityMixin,
     _WavecalQualityMixin,
 ):
@@ -64,7 +60,6 @@ class QualityMixin(
     def quality_metrics_no_task_dependence(self) -> dict:
         """Return a dict of the quality metrics with no task dependence."""
         return {
-            "TASK_TYPES": self.quality_build_task_type_counts,
             "WAVECAL_FIT": self.quality_build_wavecal_results,
         }
 

{dkist_processing_common-14.0.1 → dkist_processing_common-14.0.2}/dkist_processing_common/tasks/mixin/quality/_metrics.py

@@ -6,12 +6,7 @@ These classes should not be directly mixed in to anything. They are pre-mixed in
 import copy
 import json
 import logging
-from collections import defaultdict
 from datetime import datetime
-from functools import partial
-from typing import Any
-from typing import Iterable
-from typing import Literal
 from typing import Sequence
 
 import astropy.units as u
@@ -67,85 +62,6 @@ class _SimplePlotQualityMixin:
         return warnings
 
 
-class _TableQualityMixin:
-    """Mixing for metrics that present as tables."""
-
-    @staticmethod
-    def _create_table_metric(
-        name: str,
-        description: str,
-        metric_code: str,
-        rows: list[list[Any]],
-        statement: str | None = None,
-        warnings: list[str] | None = None,
-        facet: str | None = None,
-    ) -> dict:
-        metric = ReportMetric(
-            name=name,
-            description=description,
-            metric_code=metric_code,
-            facet=facet,
-            statement=statement,
-            table_data=SimpleTable(rows=rows),
-            warnings=warnings,
-        )
-        return metric.model_dump()
-
-    def quality_store_task_type_counts(
-        self, task_type: str, total_frames: int, frames_not_used: int = 0
-    ):
-        """
-        Collect and store task type data.
-
-        Parameters
-        ----------
-        task_type: task type as listed in the headers
-        total_frames: total number of frames supplied of the given task type
-        frames_not_used: if some frames aren't used, how many
-        """
-        data = {
-            "task_type": task_type.upper(),
-            "total_frames": total_frames,
-            "frames_not_used": frames_not_used,
-        }
-        self._record_values(values=data, tags=Tag.quality(MetricCode.task_types))
-
-    def quality_build_task_type_counts(self) -> dict:
-        """Build task type count schema from stored data."""
-        # Raise warning if more than 5% of frames of a given type are not used
-        warning_count_threshold = 0.05
-        default_int_dict = partial(defaultdict, int)
-        task_type_counts = defaultdict(default_int_dict)
-        # Loop over files that contain data for this metric
-        for path in self.read(tags=Tag.quality(MetricCode.task_types)):
-            with path.open() as f:
-                data = json.load(f)
-                task_type_counts[data["task_type"]]["total_frames"] += data["total_frames"]
-                task_type_counts[data["task_type"]]["frames_not_used"] += data["frames_not_used"]
-
-        # Now, build metric from the counts dict
-        table_data = [[i[0]] + list(i[1].values()) for i in task_type_counts.items()]
-        warnings = []
-        for row in table_data:
-            if row[1] == 0:
-                warnings.append(f"NO {row[0]} frames were used!")
-            elif row[2] / row[1] > warning_count_threshold:
-                warnings.append(
-                    f"{round(100 * row[2] / row[1], 1)}% of frames were not used in the "
-                    f"processing of task type {row[0]}"
-                )
-        # Add header row
-        table_data.insert(0, ["Task Type", "Total Frames", "Unused Frames"])
-        return self._create_table_metric(
-            name="Frame Counts",
-            description="This metric is a count of the number of frames used to produce a "
-            "calibrated L1 dataset",
-            metric_code=MetricCode.task_types,
-            rows=table_data,
-            warnings=self._format_warnings(warnings),
-        )
-
-
 class _PolcalQualityMixin:
     """Mixin Class supporting the building of polcal-specific metrics."""
 

{dkist_processing_common-14.0.1 → dkist_processing_common-14.0.2}/dkist_processing_common/tests/test_assemble_quality.py

@@ -14,11 +14,13 @@ from dkist_quality.report import ReportMetric
 from pandas import DataFrame
 
 from dkist_processing_common._util.scratch import WorkflowFileSystem
+from dkist_processing_common.codecs.basemodel import basemodel_decoder
 from dkist_processing_common.codecs.basemodel import basemodel_encoder
 from dkist_processing_common.codecs.json import json_decoder
 from dkist_processing_common.models.metric_code import MetricCode
 from dkist_processing_common.models.quality import QualityMetric
 from dkist_processing_common.models.quality import TableData
+from dkist_processing_common.models.quality import TaskCount
 from dkist_processing_common.models.quality import TimeSeriesData
 from dkist_processing_common.models.quality import XYData
 from dkist_processing_common.models.tags import Tag
@@ -76,12 +78,6 @@ def quality_metrics_old(dataframe_json) -> list[Metric]:
     Quality metric data - this OLD FORMAT is being phased out
     """
     metrics = [
-        Metric(
-            {"task_type": "dark", "total_frames": 100, "frames_not_used": 7}, ["QUALITY_TASK_TYPES"]
-        ),
-        Metric(
-            {"task_type": "gain", "total_frames": 100, "frames_not_used": 0}, ["QUALITY_TASK_TYPES"]
-        ),
         Metric(
             {
                 "param_names": ["foo"],
@@ -312,6 +308,23 @@ def quality_metrics() -> list[QualityMetric]:
             statement=[f"{MetricCode.light_level} statement."],
             description=f"{MetricCode.light_level} description.",
         ),
+        # TASK_TYPES
+        QualityMetric(
+            metric_code=MetricCode.task_types,
+            name=f"Frame Counts",
+            table_data=[
+                TableData(
+                    rows=(
+                        ("Task Type", "Total Frames", "Unused Frames"),
+                        ("dark", "1000", "1"),
+                        ("gain", "1000", "0"),
+                        ("observe", "2000", "0"),
+                    )
+                )
+            ],
+            warnings=["Past performance does not guarantee future results."],
+            description=f"{MetricCode.task_types} description.",
+        ),
     ]
     return metrics
 
@@ -473,6 +486,28 @@ def warnings_expected() -> Callable[[str], bool]:
     return expected
 
 
+@pytest.fixture()
+def assemble_quality_data_task_no_data(
+    recipe_run_id: int,
+    tmp_path: Path,
+    fake_constants_db,
+) -> AssembleQualityData:
+    """An instance of AssembleQualityData with no quality data."""
+    task = AssembleQualityData(
+        recipe_run_id=recipe_run_id,
+        workflow_name="assemble_quality",
+        workflow_version="assemble_quality_version",
+    )
+    scratch = WorkflowFileSystem(
+        recipe_run_id=recipe_run_id,
+        scratch_base_path=tmp_path,
+    )
+    task.scratch = scratch
+    task.constants._update(fake_constants_db)
+    yield task
+    task._purge()
+
+
 @pytest.fixture()
 def scratch_with_quality_metrics(
     recipe_run_id: int,
@@ -498,11 +533,10 @@ def scratch_with_quality_metrics(
 
 @pytest.fixture()
 def assemble_quality_data_task(
-    recipe_run_id,
-    tmp_path,
+    recipe_run_id: int,
+    tmp_path: Path,
     scratch_with_quality_metrics,
     fake_constants_db,
-    quality_metrics: list[QualityMetric],
 ) -> AssembleQualityData:
     """An instance of AssembleQualityData with tagged quality metrics."""
     task = AssembleQualityData(
@@ -518,7 +552,7 @@ def assemble_quality_data_task(
 
 @pytest.fixture()
 def assemble_quality_data_for_polcal_task(
-    recipe_run_id, tmp_path, scratch_with_quality_metrics, fake_constants_db
+    recipe_run_id: int, tmp_path: Path, scratch_with_quality_metrics, fake_constants_db
 ) -> AssembleQualityData:
     """An instance of AssembleQualityData with tagged quality metrics and configured to process PolCal."""
 
@@ -639,3 +673,219 @@ def test_assemble_quality_data_for_polcal(
             assert rm.statement
         if warnings_expected(rm.name):
             assert rm.warnings
+
+
+@pytest.mark.parametrize(
+    "input_task_counts, expected_metric_count, expected_task_count, expected_warning_count",
+    [
+        pytest.param([], 0, 0, 0, id="no_tasks"),
+        pytest.param(
+            [
+                TaskCount(
+                    task_type="one",
+                    total_frames=100,
+                ),
+            ],
+            1,
+            1,
+            0,
+            id="one_task",
+        ),
+        pytest.param(
+            [
+                TaskCount(
+                    task_type="one",
+                    total_frames=100,
+                    frames_not_used=6,
+                ),
+                TaskCount(
+                    task_type="two",
+                    total_frames=200,
+                    frames_not_used=10,
+                ),
+                TaskCount(
+                    task_type="three",
+                    total_frames=300,
+                    frames_not_used=16,
+                ),
+            ],
+            1,
+            3,
+            2,
+            id="three_tasks_two_outer_warnings",
+        ),
+        pytest.param(
+            [
+                TaskCount(
+                    task_type="one",
+                    total_frames=100,
+                    frames_not_used=5,
+                ),
+                TaskCount(
+                    task_type="two",
+                    total_frames=200,
+                    frames_not_used=11,
+                ),
+                TaskCount(
+                    task_type="three",
+                    total_frames=300,
+                    frames_not_used=16,
+                ),
+                TaskCount(
+                    task_type="four",
+                    total_frames=400,
+                    frames_not_used=20,
+                ),
+            ],
+            1,
+            4,
+            2,
+            id="four_tasks_two_inner_warnings",
+        ),
+    ],
+)
+def test_compute_and_write_type_counts(
+    input_task_counts,
+    expected_metric_count: int,
+    expected_task_count: int,
+    expected_warning_count: int,
+    assemble_quality_data_task_no_data: AssembleQualityData,
+):
+    """
+    Given: valid TaskCount files in scratch
+    When: executing AssembleQualityData.compute_and_write_type_counts()
+    Then: writes one FRAME_AVERAGE QualityMetric for each task type
+    Then: writes one TASK_TYPES QualityMetric
+    """
+    # Given
+    task = assemble_quality_data_task_no_data
+    for task_count in input_task_counts:
+        task.write(task_count, tags="QUALITY_TASK_TYPES", encoder=basemodel_encoder)
+
+    # When
+    task.compute_and_write_type_counts()
+
+    # Then
+    tags = [Tag.quality("GENERIC")]
+    metrics: list[QualityMetric] = list(
+        task.read(tags=tags, decoder=basemodel_decoder, model=QualityMetric)
+    )
+    assert len(metrics) == expected_metric_count
+
+    if expected_metric_count == 0:
+        # nothing to inspect
+        return
+
+    metric = metrics[0]
+    # basics
+    assert metric.metric_code == "TASK_TYPES"
+    assert metric.facet is None
+    assert metric.name == "Frame Counts"
+    assert metric.description.startswith(
+        "This metric is a count of the number of frames used to produce"
+    )
+    assert metric.statement is None
+    all_warnings = metric.warnings
+    if expected_warning_count:
+        assert isinstance(all_warnings, list)
+        assert len(all_warnings) == expected_warning_count
+        for warning in all_warnings:
+            assert "% of frames were not used in the processing of task type" in warning
+        for task_count in input_task_counts:
+            # check that each out of tolerance task generated a warning
+            if task_count.frames_not_used / task_count.total_frames > 0.05:
+                assert any(task_count.task_type in w for w in all_warnings)
+    else:
+        assert all_warnings is None
+    # data
+    all_table_data = metric.table_data
+    assert all_table_data
+    assert isinstance(all_table_data, list)
+    assert len(all_table_data) == 1
+    table_data = all_table_data[0]
+    assert isinstance(table_data, TableData)
+    rows = table_data.rows
+    assert isinstance(rows, tuple)
+    assert len(rows) == expected_task_count + 1
+    header = rows[0]
+    assert header[0] == "Task Type"
+    assert header[1] == "Total Frames"
+    assert header[2] == "Unused Frames"
+    # make sure each task got included in the table
+    for task_count in input_task_counts:
+        assert any(row[0] == task_count.task_type for row in rows[1:])
+    for row in rows[1:]:
+        # get the specific task associated with this specific row
+        input_task_count = next((it for it in input_task_counts if it.task_type == row[0]))
+        # now make sure the other attributes match
+        assert row[1] == str(input_task_count.total_frames)
+        assert row[2] == str(input_task_count.frames_not_used)
+
+
+@pytest.mark.parametrize(
+    "input_task_counts",
+    [
+        pytest.param([], id="no_tasks"),
+        pytest.param(
+            [
+                TaskCount(
+                    task_type="one",
+                    total_frames=100,
+                ),
+            ],
+            id="one_task",
+        ),
+        pytest.param(
+            [
+                TaskCount(
+                    task_type="one",
+                    total_frames=100,
+                    frames_not_used=6,
+                ),
+                TaskCount(
+                    task_type="two",
+                    total_frames=200,
+                    frames_not_used=10,
+                ),
+                TaskCount(
+                    task_type="three",
+                    total_frames=300,
+                    frames_not_used=16,
+                ),
+            ],
+            id="three_tasks",
+        ),
+    ],
+)
+def test_read_intermediate_task_type_counts(
+    input_task_counts: list[TaskCount],
+    assemble_quality_data_task_no_data: AssembleQualityData,
+):
+    """
+    Given: valid TaskCount files in scratch
+    When: executing AssembleQualityData.quality_read_intermediate_task_type_counts()
+    Then: returns one TASK_TYPES file for each TaskCount
+    """
+    # Given
+    task = assemble_quality_data_task_no_data
+    for task_count in input_task_counts:
+        task.write(task_count, tags="QUALITY_TASK_TYPES", encoder=basemodel_encoder)
+    expected_task_count = len(input_task_counts)
+
+    # When
+    returned_task_counts: list[TaskCount] = task.quality_read_intermediate_task_type_counts()
+
+    # Then
+    assert isinstance(returned_task_counts, list)
+    assert len(returned_task_counts) == expected_task_count
+    # make sure each task got returned
+    for task_count in input_task_counts:
+        assert any(rt.task_type == task_count.task_type for rt in returned_task_counts)
+    for task_count in returned_task_counts:
+        # get the specific input task associated with this one
+        input_task_count = next(
+            (it for it in input_task_counts if it.task_type == task_count.task_type)
+        )
+        # now make sure the other attributes match
+        assert task_count.total_frames == input_task_count.total_frames
+        assert task_count.frames_not_used == input_task_count.frames_not_used

{dkist_processing_common-14.0.1 → dkist_processing_common-14.0.2}/dkist_processing_common/tests/test_quality_mixin.py

@@ -97,56 +97,6 @@ def test_find_iqr_outliers(quality_mixin_task):
     ]
 
 
-def test_create_table_metric(quality_mixin_task):
-    """
-    Given: a task with the QualityMixin
-    When: submitting data to create a table metric
-    Then: the metric is encoded with the expected schema
-    """
-    task = quality_mixin_task
-    name = "table metric"
-    description = "table metric description"
-    metric_code = "TEST_METRIC"
-    rows = [["a", 1], ["b", 2], ["c", 3]]
-    statement = "table statement"
-    warnings = ["table warning"]
-    table_metric = task._create_table_metric(
-        name=name,
-        description=description,
-        rows=rows,
-        metric_code=metric_code,
-        statement=statement,
-        warnings=warnings,
-    )
-    assert table_metric["name"] == name
-    assert table_metric["description"] == description
-    assert table_metric["metric_code"] == metric_code
-    assert table_metric["facet"] is None
-    assert table_metric["statement"] == statement
-    assert table_metric["table_data"] == {"header_column": False, "header_row": True, "rows": rows}
-    assert table_metric["warnings"] == warnings
-
-
-def test_build_task_type_counts(quality_mixin_task):
-    """
-    Given: a task with the QualityMixin
-    When: writing multiple task type count data elements
-    Then: a schema is built containing all elements
-    """
-    task = quality_mixin_task
-    task.quality_store_task_type_counts(task_type="dark", total_frames=109, frames_not_used=0)
-    task.quality_store_task_type_counts(task_type="gain", total_frames=276, frames_not_used=58)
-    task.quality_store_task_type_counts(task_type="foo", total_frames=0, frames_not_used=0)
-    path = list(task.read(tags=Tag.quality("TASK_TYPES")))
-    assert len(path) == 3
-    metric = task.quality_build_task_type_counts()
-    assert metric["name"] == "Frame Counts"
-    assert metric["metric_code"] == "TASK_TYPES"
-    assert metric["facet"] is None
-    assert "21.0% of frames were not used in the processing of task type GAIN" in metric["warnings"]
-    assert "NO FOO frames were used!" in metric["warnings"]
-
-
 @pytest.mark.parametrize(
     "thin, samples_larger_than_total",
     [

{dkist_processing_common-14.0.1 → dkist_processing_common-14.0.2}/dkist_processing_common.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dkist-processing-common
-Version: 14.0.1
+Version: 14.0.2
 Summary: Common task classes used by the DKIST science data processing pipelines
 Author-email: NSO / AURA <dkistdc@nso.edu>
 License: BSD-3-Clause