dkist-processing-common 10.5.4__py3-none-any.whl → 12.1.0rc1__py3-none-any.whl

dkist_processing_common/parsers/time.py

@@ -1,15 +1,18 @@
 """Time parser."""
+
 from datetime import datetime
 from datetime import timezone
+from enum import StrEnum
 from typing import Callable
-from typing import Hashable
 from typing import Type
 
 import numpy as np
 
 from dkist_processing_common.models.constants import BudName
+from dkist_processing_common.models.fits_access import MetadataKey
+from dkist_processing_common.models.flower_pot import ListStem
+from dkist_processing_common.models.flower_pot import SetStem
 from dkist_processing_common.models.flower_pot import SpilledDirt
-from dkist_processing_common.models.flower_pot import Stem
 from dkist_processing_common.models.tags import EXP_TIME_ROUND_DIGITS
 from dkist_processing_common.models.tags import StemName
 from dkist_processing_common.models.task_name import TaskName
@@ -19,7 +22,6 @@ from dkist_processing_common.parsers.single_value_single_key_flower import (
 )
 from dkist_processing_common.parsers.task import passthrough_header_ip_task
 from dkist_processing_common.parsers.unique_bud import TaskUniqueBud
-from dkist_processing_common.parsers.unique_bud import UniqueBud
 
 
 class ObsIpStartTimeBud(TaskUniqueBud):
@@ -27,21 +29,56 @@ class ObsIpStartTimeBud(TaskUniqueBud):
 
     def __init__(self):
         super().__init__(
-            constant_name=BudName.obs_ip_start_time.value,
-            metadata_key="ip_start_time",
-            ip_task_type=TaskName.observe.value,
+            constant_name=BudName.obs_ip_start_time,
+            metadata_key=MetadataKey.ip_start_time,
+            ip_task_types=TaskName.observe,
         )
 
 
-class CadenceBudBase(UniqueBud):
-    """Base class for all Cadence Buds."""
+class TaskDatetimeBudBase(ListStem):
+    """
+    Base class for making datetime-related buds.
 
-    def __init__(self, constant_name: str):
-        super().__init__(constant_name, metadata_key="time_obs")
+    Returns a tuple of sorted values converted from datetimes to unix seconds.
+
+    Complicated parsing of the header into a task type can be achieved by passing in a different
+    header task parsing function.
+
+    Parameters
+    ----------
+    stem_name
+        The name for the constant to be defined
+
+    metadata_key
+        The metadata key associated with the constant
+
+    ip_task_types
+        Only consider objects whose parsed header IP task type matches a string in this list
+
+    header_type_parsing_func
+        The function used to convert a header into an IP task type
+    """
+
+    def __init__(
+        self,
+        stem_name: str,
+        metadata_key: str | StrEnum,
+        ip_task_types: str | list[str],
+        task_type_parsing_function: Callable = passthrough_header_ip_task,
+    ):
+        super().__init__(stem_name=stem_name)
+
+        if isinstance(metadata_key, StrEnum):
+            metadata_key = metadata_key.name
+        self.metadata_key = metadata_key
+        if isinstance(ip_task_types, str):
+            ip_task_types = [ip_task_types]
+        self.ip_task_types = [task.casefold() for task in ip_task_types]
+        self.header_parsing_function = task_type_parsing_function
 
     def setter(self, fits_obj: L0FitsAccess) -> float | Type[SpilledDirt]:
         """
-        If the file is an observe file, its DATE-OBS value is stored as unix seconds.
+        Store the metadata key datetime value as unix seconds if the task type is in the desired types.
 
         Parameters
         ----------
@@ -49,106 +86,141 @@ class CadenceBudBase(UniqueBud):
             The input fits object
         Returns
         -------
-        The observe time in seconds
+        The datetime in seconds
         """
-        if fits_obj.ip_task_type.casefold() == TaskName.observe.value.casefold():
+        task = self.header_parsing_function(fits_obj)
+
+        if task.casefold() in self.ip_task_types:
             return (
                 datetime.fromisoformat(getattr(fits_obj, self.metadata_key))
                 .replace(tzinfo=timezone.utc)
                 .timestamp()
             )
+
         return SpilledDirt
 
+    def getter(self) -> tuple[float, ...]:
+        """
+        Return a tuple of sorted times in unix seconds.
+
+        Returns
+        -------
+        A tuple that is sorted times in unix seconds
+        """
+        return tuple(sorted(self.value_list))
+
+
+class CadenceBudBase(TaskDatetimeBudBase):
+    """Base class for all Cadence Buds."""
+
+    def __init__(self, constant_name: str):
+        super().__init__(
+            stem_name=constant_name,
+            metadata_key=MetadataKey.time_obs,
+            ip_task_types=TaskName.observe,
+        )
+
 
 class AverageCadenceBud(CadenceBudBase):
     """Class for the average cadence Bud."""
 
     def __init__(self):
-        super().__init__(constant_name=BudName.average_cadence.value)
+        super().__init__(constant_name=BudName.average_cadence)
 
-    def getter(self, key) -> np.float64:
+    def getter(self) -> np.float64:
         """
         Return the mean cadence between frames.
 
-        Parameters
-        ----------
-        key
-            The input key
-
         Returns
         -------
         The mean value of the cadences of the input frames
         """
-        return np.mean(np.diff(sorted(list(self.key_to_petal_dict.values()))))
+        return np.mean(np.diff(super().getter()))
 
 
 class MaximumCadenceBud(CadenceBudBase):
     """Class for the maximum cadence bud."""
 
     def __init__(self):
-        super().__init__(constant_name=BudName.maximum_cadence.value)
+        super().__init__(constant_name=BudName.maximum_cadence)
 
-    def getter(self, key) -> np.float64:
+    def getter(self) -> np.float64:
         """
         Return the maximum cadence between frames.
 
-        Parameters
-        ----------
-        key
-            The input key
-
         Returns
         -------
         The maximum cadence between frames
         """
-        return np.max(np.diff(sorted(list(self.key_to_petal_dict.values()))))
+        return np.max(np.diff(super().getter()))
 
 
 class MinimumCadenceBud(CadenceBudBase):
     """Class for the minimum cadence bud."""
 
     def __init__(self):
-        super().__init__(constant_name=BudName.minimum_cadence.value)
+        super().__init__(constant_name=BudName.minimum_cadence)
 
-    def getter(self, key) -> np.float64:
+    def getter(self) -> np.float64:
         """
         Return the minimum cadence between frames.
 
-        Parameters
-        ----------
-        key
-            The input key
-
         Returns
         -------
         The minimum cadence between frames
         """
-        return np.min(np.diff(sorted(list(self.key_to_petal_dict.values()))))
+        return np.min(np.diff(super().getter()))
 
 
 class VarianceCadenceBud(CadenceBudBase):
     """Class for the variance cadence Bud."""
 
     def __init__(self):
-        super().__init__(constant_name=BudName.variance_cadence.value)
+        super().__init__(constant_name=BudName.variance_cadence)
 
-    def getter(self, key) -> np.float64:
+    def getter(self) -> np.float64:
         """
         Return the cadence variance between frames.
 
-        Parameters
-        ----------
-        key
-            The input key
         Returns
         -------
         Return the variance of the cadences over the input frames
         """
-        return np.var(np.diff(sorted(list(self.key_to_petal_dict.values()))))
+        return np.var(np.diff(super().getter()))
 
 
-class TimeFlowerBase(SingleValueSingleKeyFlower):
-    """Base task for SingleValueSingleKeyFlowers that need to round their values to avoid value jitter."""
+class TaskDateBeginBud(TaskDatetimeBudBase):
+    """Class for the date begin task Bud."""
+
+    def __init__(
+        self,
+        constant_name: str,
+        ip_task_types: str | list[str],
+        task_type_parsing_function: Callable = passthrough_header_ip_task,
+    ):
+        super().__init__(
+            stem_name=constant_name,
+            metadata_key=MetadataKey.time_obs,
+            ip_task_types=ip_task_types,
+            task_type_parsing_function=task_type_parsing_function,
+        )
+
+    def getter(self) -> str:
+        """
+        Return the earliest date begin for the ip task type converted from unix seconds to datetime string.
+
+        Returns
+        -------
+        Return the minimum date begin as a datetime string
+        """
+        # super().getter() returns a sorted list
+        min_time = super().getter()[0]
+        min_time_dt = datetime.fromtimestamp(min_time, tz=timezone.utc)
+        return min_time_dt.strftime("%Y-%m-%dT%H:%M:%S.%f")
+
+
+class RoundTimeFlowerBase(SingleValueSingleKeyFlower):
+    """Base flower for SingleValueSingleKeyFlowers that need to round their values to avoid value jitter."""
 
     def setter(self, fits_obj: L0FitsAccess):
         """
@@ -166,92 +238,126 @@ class TimeFlowerBase(SingleValueSingleKeyFlower):
         return round(raw_value, EXP_TIME_ROUND_DIGITS)
 
 
-class ExposureTimeFlower(TimeFlowerBase):
+class ExposureTimeFlower(RoundTimeFlowerBase):
     """For tagging the frame FPA exposure time."""
 
     def __init__(self):
         super().__init__(
-            tag_stem_name=StemName.exposure_time.value, metadata_key="fpa_exposure_time_ms"
+            tag_stem_name=StemName.exposure_time, metadata_key=MetadataKey.fpa_exposure_time_ms
         )
 
 
-class ReadoutExpTimeFlower(TimeFlowerBase):
+class ReadoutExpTimeFlower(RoundTimeFlowerBase):
     """For tagging the exposure time of each readout that contributes to an FPA."""
 
     def __init__(self):
         super().__init__(
-            tag_stem_name=StemName.readout_exp_time.value,
-            metadata_key="sensor_readout_exposure_time_ms",
+            tag_stem_name=StemName.readout_exp_time,
+            metadata_key=MetadataKey.sensor_readout_exposure_time_ms,
         )
 
 
-class TaskTimeBudBase(Stem):
+class TaskRoundTimeBudBase(SetStem):
     """
-    Base class for making time-related buds that are computed for a specific task type.
+    Base class for making buds that need a set of rounded times for computing for specific task types.
 
-    By "time-related" we mean values that generally need rounding when ingested into the database.
+    Metadata key values are already floats.  Returns tuple of sorted unique rounded values.
 
     Complicated parsing of the header into a task type can be achieved by passing in a different
     header task parsing function.
+
+    Parameters
+    ----------
+    stem_name
+        The name for the constant to be defined
+
+    metadata_key
+        The metadata key associated with the constant
+
+    ip_task_types
+        Only consider objects whose parsed header IP task type matches a string in this list
+
+    header_task_parsing_func
+        The function used to convert a header into an IP task type
     """
 
     def __init__(
         self,
         stem_name: str,
-        metadata_key: str,
-        ip_task_type: str,
+        metadata_key: str | StrEnum,
+        ip_task_types: str | list[str],
         header_task_parsing_func: Callable = passthrough_header_ip_task,
     ):
         super().__init__(stem_name=stem_name)
+
+        if isinstance(metadata_key, StrEnum):
+            metadata_key = metadata_key.name
         self.metadata_key = metadata_key
-        self.ip_task_type = ip_task_type
+        if isinstance(ip_task_types, str):
+            ip_task_types = [ip_task_types]
+        self.ip_task_types = [task.casefold() for task in ip_task_types]
         self.header_parsing_function = header_task_parsing_func
 
-    def setter(self, fits_obj: L0FitsAccess):
-        """Return the desired metadata key only if the parsed task type matches the Bud's task type."""
+    def setter(self, fits_obj: L0FitsAccess) -> float | Type[SpilledDirt]:
+        """
+        Store the metadata key value if the parsed task type is in the desired types.
+
+        Parameters
+        ----------
+        fits_obj
+            The input fits object
+        Returns
+        -------
+        The rounded time
+        """
         task = self.header_parsing_function(fits_obj)
 
-        if task.casefold() == self.ip_task_type.casefold():
+        if task.casefold() in self.ip_task_types:
             raw_value = getattr(fits_obj, self.metadata_key)
             return round(raw_value, EXP_TIME_ROUND_DIGITS)
 
         return SpilledDirt
 
-    def getter(self, key: Hashable) -> tuple[float, ...]:
-        """Return a tuple of all the unique values found."""
-        value_tuple = tuple(sorted(set(self.key_to_petal_dict.values())))
-        return value_tuple
+    def getter(self) -> tuple[float, ...]:
+        """
+        Return a tuple of the sorted unique values found.
+
+        Returns
+        -------
+        A tuple that is the sorted set of unique times
+        """
+        return tuple(sorted(self.value_set))
 
 
-class TaskExposureTimesBud(TaskTimeBudBase):
+class TaskExposureTimesBud(TaskRoundTimeBudBase):
     """Produce a tuple of all FPA exposure times present in the dataset for a specific ip task type."""
 
     def __init__(
         self,
         stem_name: str,
-        ip_task_type: str,
+        ip_task_types: str | list[str],
         header_task_parsing_func: Callable = passthrough_header_ip_task,
     ):
         super().__init__(
             stem_name=stem_name,
-            metadata_key="fpa_exposure_time_ms",
-            ip_task_type=ip_task_type,
+            metadata_key=MetadataKey.fpa_exposure_time_ms,
+            ip_task_types=ip_task_types,
             header_task_parsing_func=header_task_parsing_func,
         )
 
 
-class TaskReadoutExpTimesBud(TaskTimeBudBase):
+class TaskReadoutExpTimesBud(TaskRoundTimeBudBase):
     """Produce a tuple of all sensor readout exposure times present in the dataset for a specific task type."""
 
     def __init__(
         self,
         stem_name: str,
-        ip_task_type: str,
+        ip_task_types: str | list[str],
         header_task_parsing_func: Callable = passthrough_header_ip_task,
     ):
         super().__init__(
             stem_name=stem_name,
-            metadata_key="sensor_readout_exposure_time_ms",
-            ip_task_type=ip_task_type,
+            metadata_key=MetadataKey.sensor_readout_exposure_time_ms,
+            ip_task_types=ip_task_types,
             header_task_parsing_func=header_task_parsing_func,
         )

dkist_processing_common/parsers/unique_bud.py

@@ -1,15 +1,17 @@
 """Pre-made flower that reads a single header key from all files and raises a ValueError if it is not unique."""
+
+from enum import StrEnum
 from typing import Callable
 
+from dkist_processing_common.models.flower_pot import SetStem
 from dkist_processing_common.models.flower_pot import SpilledDirt
-from dkist_processing_common.models.flower_pot import Stem
 from dkist_processing_common.parsers.l0_fits_access import L0FitsAccess
 from dkist_processing_common.parsers.task import passthrough_header_ip_task
 
 
-class UniqueBud(Stem):
+class UniqueBud(SetStem):
     """
-    Pre-made flower that reads a single header key from all files and raises a ValueError if it is not unique.
+    Pre-made `SetStem` that reads a single header key from all files and raises a ValueError if it is not unique.
 
     Parameters
     ----------
@@ -23,9 +25,11 @@ class UniqueBud(Stem):
     def __init__(
         self,
         constant_name: str,
-        metadata_key: str,
+        metadata_key: str | StrEnum,
     ):
         super().__init__(stem_name=constant_name)
+        if isinstance(metadata_key, StrEnum):
+            metadata_key = metadata_key.name
         self.metadata_key = metadata_key
 
     def setter(self, fits_obj: L0FitsAccess):
@@ -42,29 +46,22 @@ class UniqueBud(Stem):
         """
         return getattr(fits_obj, self.metadata_key)
 
-    def getter(self, key):
+    def getter(self):
         """
         Get the value for this key and raise an error if it is not unique.
 
-        Parameters
-        ----------
-        key
-            The input key
         Returns
         -------
         The value associated with this input key
         """
-        value_set = set(self.key_to_petal_dict.values())
-        if len(value_set) > 1:
-            raise ValueError(
-                f"Multiple {self.stem_name} values found for key {key}. Values: {value_set}"
-            )
-        return value_set.pop()
+        if len(self.value_set) > 1:
+            raise ValueError(f"Multiple {self.stem_name} values found! Values: {self.value_set}")
+        return self.value_set.pop()
 
 
 class TaskUniqueBud(UniqueBud):
     """
-    Subclass of `UniqueBud` that only considers objects that have a specific task type.
+    Subclass of `UniqueBud` that only considers objects that have specific task types.
 
     Parameters
     ----------
@@ -74,8 +71,8 @@ class TaskUniqueBud(UniqueBud):
     metadata_key
         The metadata key associated with the constant
 
-    ip_task_type
-        Only consider objects whose parsed header IP task type matches this string
+    ip_task_types
+        Only consider objects whose parsed header IP task type matches a string in this list
 
     task_type_parsing_function
         The function used to convert a header into an IP task type
@@ -84,20 +81,22 @@ class TaskUniqueBud(UniqueBud):
     def __init__(
         self,
         constant_name: str,
-        metadata_key: str,
-        ip_task_type: str,
+        metadata_key: str | StrEnum,
+        ip_task_types: str | list[str],
         task_type_parsing_function: Callable = passthrough_header_ip_task,
     ):
         super().__init__(constant_name=constant_name, metadata_key=metadata_key)
 
-        self.ip_task_type = ip_task_type.casefold()
+        if isinstance(ip_task_types, str):
+            ip_task_types = [ip_task_types]
+        self.ip_task_types = [task.casefold() for task in ip_task_types]
         self.parsing_function = task_type_parsing_function
 
     def setter(self, fits_obj: L0FitsAccess):
         """Ingest an object only if its parsed IP task type matches what's desired."""
         task = self.parsing_function(fits_obj)
 
-        if task.casefold() == self.ip_task_type:
+        if task.casefold() in self.ip_task_types:
             return super().setter(fits_obj)
 
         return SpilledDirt

dkist_processing_common/parsers/wavelength.py

@@ -1,5 +1,7 @@
 """Bud to get the wavelength of observe frames."""
+
 from dkist_processing_common.models.constants import BudName
+from dkist_processing_common.models.fits_access import MetadataKey
 from dkist_processing_common.models.task_name import TaskName
 from dkist_processing_common.parsers.unique_bud import TaskUniqueBud
 
@@ -9,7 +11,7 @@ class ObserveWavelengthBud(TaskUniqueBud):
 
     def __init__(self):
         super().__init__(
-            constant_name=BudName.wavelength.value,
-            metadata_key="wavelength",
-            ip_task_type=TaskName.observe.value,
+            constant_name=BudName.wavelength,
+            metadata_key=MetadataKey.wavelength,
+            ip_task_types=TaskName.observe,
         )

dkist_processing_common/tasks/__init__.py

@@ -1,11 +1,12 @@
 """Common tasks and bases."""
-from dkist_processing_common.tasks.base import *  # noreorder
+
+from dkist_processing_common.tasks.base import *  # isort: skip
 from dkist_processing_common.tasks.assemble_movie import *
 from dkist_processing_common.tasks.l1_output_data import *
 from dkist_processing_common.tasks.parse_l0_input_data import *
 from dkist_processing_common.tasks.quality_metrics import *
 from dkist_processing_common.tasks.teardown import *
 from dkist_processing_common.tasks.transfer_input_data import *
-from dkist_processing_common.tasks.write_l1 import *
 from dkist_processing_common.tasks.trial_catalog import *
 from dkist_processing_common.tasks.trial_output_data import *
+from dkist_processing_common.tasks.write_l1 import *

dkist_processing_common/tasks/assemble_movie.py

@@ -1,11 +1,12 @@
 """Task(s) for assembling a browse movie."""
+
 import logging
 from abc import ABC
 from abc import abstractmethod
+from importlib.resources import files
 from typing import Literal
 
 import numpy as np
-import pkg_resources
 from matplotlib import colormaps
 from moviepy import VideoClip
 from PIL import Image
@@ -66,7 +67,7 @@ class AssembleMovie(WorkflowTaskBase, ABC):
     MINIMUM_DURATION = 10  # seconds
     MAXIMUM_DURATION = 60  # seconds
     FPS = 15
-    FONT_FILE = pkg_resources.resource_filename("dkist_processing_common", "fonts/Lato-Regular.ttf")
+    FONT_FILE = files("dkist_processing_common").joinpath("fonts/Lato-Regular.ttf")
     TEXT_MARGIN_PX = 5
     MPL_COLOR_MAP = "viridis"
 
@@ -162,7 +163,7 @@ class AssembleMovie(WorkflowTaskBase, ABC):
         relative_movie_path = f"{self.constants.dataset_id}_browse_movie.mp4"
         absolute_movie_path = str(self.scratch.absolute_path(relative_movie_path))
 
-        with self.apm_processing_step("Assembling movie frames"):
+        with self.telemetry_span("Assembling movie frames"):
             clip.write_videofile(absolute_movie_path, fps=self.FPS, codec="libx264", audio=False)
 
         self.tag(path=absolute_movie_path, tags=[Tag.movie(), Tag.output()])