spectre-core 0.0.23__py3-none-any.whl → 0.0.24__py3-none-any.whl

spectre_core/__init__.py

@@ -0,0 +1,5 @@
+# SPDX-FileCopyrightText: © 2024-2025 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+__version__ = "0.0.24"

spectre_core/config/__init__.py

@@ -5,6 +5,8 @@
 
 """General `spectre` package configurations."""
 
+import os
+
 from ._paths import (
     get_spectre_data_dir_path,
     get_batches_dir_path,
@@ -14,6 +16,10 @@ from ._paths import (
 )
 from ._time_formats import TimeFormat
 
+os.makedirs(get_batches_dir_path(), exist_ok=True)
+os.makedirs(get_logs_dir_path(), exist_ok=True)
+os.makedirs(get_configs_dir_path(), exist_ok=True)
+
 __all__ = [
     "get_spectre_data_dir_path",
     "get_batches_dir_path",

spectre_core/config/_paths.py

@@ -16,24 +16,17 @@ and creates three directories inside it:
 import os
 from typing import Optional
 
-_SPECTRE_DATA_DIR_PATH = os.environ.get("SPECTRE_DATA_DIR_PATH", "NOTSET")
-if _SPECTRE_DATA_DIR_PATH == "NOTSET":
-    raise ValueError("The environment variable `SPECTRE_DATA_DIR_PATH` must be set.")
-
-_BATCHES_DIR_PATH = os.path.join(_SPECTRE_DATA_DIR_PATH, "batches")
-_LOGS_DIR_PATH = os.path.join(_SPECTRE_DATA_DIR_PATH, "logs")
-_CONFIGS_DIR_PATH = os.path.join(_SPECTRE_DATA_DIR_PATH, "configs")
-
-os.makedirs(_BATCHES_DIR_PATH, exist_ok=True)
-os.makedirs(_LOGS_DIR_PATH, exist_ok=True)
-os.makedirs(_CONFIGS_DIR_PATH, exist_ok=True)
-
 
 def get_spectre_data_dir_path() -> str:
     """The default ancestral path for all `spectre` file system data.
 
     :return: The value stored by the `SPECTRE_DATA_DIR_PATH` environment variable.
     """
+    _SPECTRE_DATA_DIR_PATH = os.environ.get("SPECTRE_DATA_DIR_PATH", "NOTSET")
+    if _SPECTRE_DATA_DIR_PATH == "NOTSET":
+        raise ValueError(
+            "The environment variable `SPECTRE_DATA_DIR_PATH` must be set."
+        )
     return _SPECTRE_DATA_DIR_PATH
 
 
@@ -80,7 +73,8 @@ def get_batches_dir_path(
     :param day: The numeric day. Defaults to None.
     :return: The directory path for batched data files, optionally with a date-based subdirectory.
     """
-    return _get_date_based_dir_path(_BATCHES_DIR_PATH, year, month, day)
+    batches_dir_path = os.path.join(get_spectre_data_dir_path(), "batches")
+    return _get_date_based_dir_path(batches_dir_path, year, month, day)
 
 
 def get_logs_dir_path(
@@ -94,7 +88,8 @@ def get_logs_dir_path(
     :param day: The numeric day. Defaults to None.
     :return: The directory path for log files, optionally with a date-based subdirectory.
     """
-    return _get_date_based_dir_path(_LOGS_DIR_PATH, year, month, day)
+    logs_dir_path = os.path.join(get_spectre_data_dir_path(), "logs")
+    return _get_date_based_dir_path(logs_dir_path, year, month, day)
 
 
 def get_configs_dir_path() -> str:
@@ -102,7 +97,7 @@ def get_configs_dir_path() -> str:
 
     :return: The directory path for configuration files.
     """
-    return _CONFIGS_DIR_PATH
+    return os.path.join(get_spectre_data_dir_path(), "configs")
 
 
 def trim_spectre_data_dir_path(full_path: str) -> str:
@@ -116,7 +111,7 @@ def trim_spectre_data_dir_path(full_path: str) -> str:
     :param full_path: The full file path to be trimmed.
     :return: The relative path with `SPECTRE_DATA_DIR_PATH` removed.
     """
-    return os.path.relpath(full_path, _SPECTRE_DATA_DIR_PATH)
+    return os.path.relpath(full_path, get_spectre_data_dir_path())
 
 
 def add_spectre_data_dir_path(rel_path: str) -> str:
@@ -129,4 +124,4 @@ def add_spectre_data_dir_path(rel_path: str) -> str:
     :param rel_path: The relative file path to be appended.
     :return: The full file path prefixed with `SPECTRE_DATA_DIR_PATH`.
     """
-    return os.path.join(_SPECTRE_DATA_DIR_PATH, rel_path)
+    return os.path.join(get_spectre_data_dir_path(), rel_path)

spectre_core/plotting/__init__.py

@@ -5,6 +5,8 @@
 """An intuitive API for plotting spectrogram data."""
 
 from ._format import PanelFormat
+from ._panel_names import PanelName
+from ._base import BasePanel, BaseTimeSeriesPanel, XAxisType
 from ._panels import (
     SpectrogramPanel,
     FrequencyCutsPanel,
@@ -14,6 +16,10 @@ from ._panels import (
 from ._panel_stack import PanelStack
 
 __all__ = [
+    "BaseTimeSeriesPanel",
+    "PanelName",
+    "XAxisType",
+    "BasePanel",
     "PanelFormat",
     "PanelStack",
     "SpectrogramPanel",

spectre_core/plotting/_base.py

@@ -20,7 +20,7 @@ from ._panel_names import PanelName
 
 
 class XAxisType(Enum):
-    """The x-axis type for a panel.
+    """The xaxis type for a panel.
 
     Axes are shared in a stack between panels with common `XAxisType`.
 
@@ -37,23 +37,30 @@ class BasePanel(ABC):
 
     `BasePanel` instances are designed to be part of a `PanelStack`, where multiple
     panels contribute to a composite plot. Subclasses must implement methods to define
-    how the panel is drawn and annotated, and specify its x-axis type.
+    how the panel is drawn and annotated, and specify its xaxis type.
     """
 
-    def __init__(self, name: PanelName, spectrogram: Spectrogram) -> None:
+    def __init__(
+        self,
+        name: PanelName,
+        spectrogram: Spectrogram,
+        time_type: TimeType = TimeType.RELATIVE,
+    ) -> None:
         """Initialize an instance of `BasePanel`.
 
         :param name: The name of the panel.
         :param spectrogram: The spectrogram being visualised.
+        :param time_type: Indicates whether the times of each spectrum are relative to the first
+        spectrum in the spectrogram, or datetimes.
         """
         self._name = name
         self._spectrogram = spectrogram
+        self._time_type = time_type
 
-        # internal attributes set by `PanelStack` during stacking.
-        self._panel_format: Optional[PanelFormat] = None
-        self._time_type: Optional[TimeType] = None
+        # These attributes should be set by instances of `PanelStack`.
         self._ax: Optional[Axes] = None
         self._fig: Optional[Figure] = None
+        self._panel_format: Optional[PanelFormat] = None
         self._identifier: Optional[str] = None
 
     @abstractmethod
@@ -62,16 +69,16 @@ class BasePanel(ABC):
 
     @abstractmethod
     def annotate_xaxis(self) -> None:
-        """Modify the `ax` attribute to annotate the x-axis of the panel."""
+        """Modify the `ax` attribute to annotate the xaxis of the panel."""
 
     @abstractmethod
     def annotate_yaxis(self) -> None:
-        """Modify the `ax` attribute to annotate the y-axis of the panel."""
+        """Modify the `ax` attribute to annotate the yaxis of the panel."""
 
     @property
     @abstractmethod
     def xaxis_type(self) -> XAxisType:
-        """Specify the x-axis type for the panel."""
+        """Specify the xaxis type for the panel."""
 
     @property
     def spectrogram(self) -> Spectrogram:
@@ -84,17 +91,18 @@ class BasePanel(ABC):
         return self._spectrogram.tag
 
     @property
-    def time_type(self) -> TimeType:
+    def name(self) -> PanelName:
+        """The name of the panel."""
+        return self._name
+
+    def get_time_type(self) -> TimeType:
         """The time type of the spectrogram.
 
         :raises ValueError: If the `time_type` has not been set.
         """
-        if self._time_type is None:
-            raise ValueError(f"`time_type` for the panel '{self.name}' must be set.")
         return self._time_type
 
-    @time_type.setter
-    def time_type(self, value: TimeType) -> None:
+    def set_time_type(self, value: TimeType) -> None:
         """Set the `TimeType` for the spectrogram.
 
         This controls how time is represented and annotated on the panel.
@@ -103,41 +111,35 @@ class BasePanel(ABC):
         """
         self._time_type = value
 
-    @property
-    def name(self) -> PanelName:
-        """The name of the panel."""
-        return self._name
-
-    @property
-    def panel_format(self) -> PanelFormat:
+    def get_panel_format(self) -> PanelFormat:
         """Retrieve the panel format, which controls the style of the panel.
 
         :raises ValueError: If the `panel_format` has not been set.
         """
         if self._panel_format is None:
-            raise ValueError(f"`panel_format` for the panel '{self.name}' must be set.")
+            raise ValueError(f"`panel_format` must be set for the panel `{self.name}`")
         return self._panel_format
 
-    @panel_format.setter
-    def panel_format(self, value: PanelFormat) -> None:
+    def set_panel_format(self, value: PanelFormat) -> None:
         """Set the panel format to control the style of the panel.
 
         :param value: The `PanelFormat` to assign to the panel.
         """
         self._panel_format = value
 
-    @property
-    def ax(self) -> Axes:
-        """The `Axes` object bound to this panel.
+    def _get_ax(self) -> Axes:
+        """Return the `Axes` object bound to this panel.
 
-        :raises AttributeError: If the `Axes` object has not been set.
+        This method is protected to restrict direct access to `matplotlib` functionality,
+        promoting encapsulation, promoting encapsulation.
+
+        :raises ValueError: If the `Axes` object has not been set.
         """
         if self._ax is None:
-            raise AttributeError(f"`ax` must be set for the panel `{self.name}`")
+            raise ValueError(f"`ax` must be set for the panel `{self.name}`")
         return self._ax
 
-    @ax.setter
-    def ax(self, value: Axes) -> None:
+    def set_ax(self, value: Axes) -> None:
         """Assign a Matplotlib `Axes` object to this panel.
 
         This `Axes` will be used for drawing and annotations.
@@ -146,19 +148,19 @@ class BasePanel(ABC):
         """
         self._ax = value
 
-    @property
-    def fig(self) -> Figure:
-        """
-        The `Figure` object bound to this panel.
+    def _get_fig(self) -> Figure:
+        """Return the `Figure` object bound to this panel.
+
+        This method is protected to restrict direct access to `matplotlib` functionality,
+        promoting encapsulation, promoting encapsulation.
 
-        :raises AttributeError: If the `Figure` object has not been set.
+        :raises ValueError: If the `Figure` object has not been set.
         """
         if self._fig is None:
-            raise AttributeError(f"`fig` must be set for the panel `{self.name}`")
+            raise ValueError(f"`fig` must be set for the panel `{self.name}`")
         return self._fig
 
-    @fig.setter
-    def fig(self, value: Figure) -> None:
+    def set_fig(self, value: Figure) -> None:
         """
         Assign a Matplotlib `Figure` object to this panel.
 
@@ -168,8 +170,7 @@ class BasePanel(ABC):
         """
         self._fig = value
 
-    @property
-    def identifier(self) -> Optional[str]:
+    def get_identifier(self) -> Optional[str]:
         """Optional identifier for the panel.
 
         This identifier can be used to distinguish panels or aid in superimposing
@@ -177,8 +178,7 @@ class BasePanel(ABC):
         """
         return self._identifier
 
-    @identifier.setter
-    def identifier(self, value: str) -> None:
+    def set_identifier(self, value: str) -> None:
         """Set the optional identifier for the panel.
 
         This can be used to distinguish panels or aid in superimposing panels.
@@ -186,12 +186,40 @@ class BasePanel(ABC):
         self._identifier = value
 
     def hide_xaxis_labels(self) -> None:
-        """Hide the x-axis labels for this panel."""
-        self.ax.tick_params(axis="x", labelbottom=False)
+        """Hide the labels for xaxis ticks in the panel."""
+        self._get_ax().tick_params(axis="x", labelbottom=False)
 
     def hide_yaxis_labels(self) -> None:
-        """Hide the y-axis labels for this panel."""
-        self.ax.tick_params(axis="y", labelbottom=False)
+        """Hide the labels for yaxis ticks in the panel."""
+        self._get_ax().tick_params(axis="y", labelleft=False)
+
+    def sharex(self, axes: Axes):
+        """Share the xaxis with another axes."""
+        self._get_ax().sharex(axes)
+
+    def get_xaxis_labels(self) -> list[str]:
+        """Get the text string of all xaxis tick labels."""
+        tick_labels = self._get_ax().get_xaxis().get_ticklabels(which="both")
+        return [tick_label.get_text() for tick_label in tick_labels]
+
+    def get_yaxis_labels(self) -> list[str]:
+        """Get the text string of all yaxis tick labels."""
+        tick_labels = self._get_ax().get_yaxis().get_ticklabels(which="both")
+        return [tick_label.get_text() for tick_label in tick_labels]
+
+    def get_xlabel(self) -> str:
+        """Get the xlabel text string."""
+        return self._get_ax().get_xlabel()
+
+    def get_ylabel(self) -> str:
+        """Get the ylabel text string."""
+        return self._get_ax().get_ylabel()
+
+    def share_axes(self, panel: "BasePanel") -> None:
+        # TODO: More elegantly share axes, rather than access protected method from
+        # another instance. Probably, this should just be entirely managed by the `PanelStack`
+        self.set_ax(panel._get_ax())
+        self.set_fig(panel._get_fig())
 
 
 class BaseTimeSeriesPanel(BasePanel):
@@ -210,38 +238,19 @@ class BaseTimeSeriesPanel(BasePanel):
         """The times assigned to each spectrum according to the `TimeType`."""
         return (
             self.spectrogram.times
-            if self.time_type == TimeType.RELATIVE
+            if self.get_time_type() == TimeType.RELATIVE
             else self.spectrogram.datetimes
         )
 
     def annotate_xaxis(self) -> None:
-        """Annotate the x-axis according to the specified `TimeType`."""
-        if self.time_type == TimeType.RELATIVE:
-            self.ax.set_xlabel("Time [s]")
+        """Annotate the xaxis according to the specified `TimeType`."""
+        ax = self._get_ax()
+        if self.get_time_type() == TimeType.RELATIVE:
+            ax.set_xlabel("Time [s]")
         else:
             # TODO: Adapt for time ranges greater than one day
             start_date = datetime.strftime(
                 self.spectrogram.start_datetime.astype(datetime), TimeFormat.DATE
             )
-            self.ax.set_xlabel(f"Time [UTC] (Start Date: {start_date})")
-            self.ax.xaxis.set_major_formatter(mdates.DateFormatter(TimeFormat.TIME))
-
-
-class BaseSpectrumPanel(BasePanel):
-    """An abstract subclass of `BasePanel` tailored for visualising spectrum data.
-
-    Subclasses must implement any remaining abstract methods as described by `BasePanel`.
-    """
-
-    @property
-    def xaxis_type(self) -> Literal[XAxisType.FREQUENCY]:
-        return XAxisType.FREQUENCY
-
-    @property
-    def frequencies(self) -> npt.NDArray[np.float32]:
-        """The physical frequencies assigned to each spectral component."""
-        return self._spectrogram.frequencies
-
-    def annotate_xaxis(self) -> None:
-        """Annotate the x-axis assuming frequency in units of Hz."""
-        self.ax.set_xlabel("Frequency [Hz]")
+            ax.set_xlabel(f"Time [UTC] (Start Date: {start_date})")
+            ax.xaxis.set_major_formatter(mdates.DateFormatter(TimeFormat.TIME))

spectre_core/plotting/_panel_stack.py

@@ -66,18 +66,48 @@ class PanelStack:
         self._fig: Optional[Figure] = None
         self._axs: Optional[np.ndarray] = None
 
-    @property
-    def time_type(self) -> TimeType:
-        """The type of time we assign to the spectrograms"""
-        return self._time_type
+    def _sort_by_xaxis_type(self, panels: list[BasePanel]) -> list[BasePanel]:
+        return list(sorted(panels, key=lambda panel: panel.xaxis_type.value))
 
     @property
     def panels(self) -> list[BasePanel]:
         """Get the panels in the stack, sorted by their `XAxisType`."""
-        return list(sorted(self._panels, key=lambda panel: panel.xaxis_type.value))
+        return self._sort_by_xaxis_type(self._panels)
+
+    @property
+    def superimposed_panels(self) -> list[BasePanel]:
+        """Get the superimposed panels in the stack, sorted by their `XAxisType"""
+        return self._sort_by_xaxis_type(self._superimposed_panels)
+
+    @property
+    def num_panels(self) -> int:
+        """Get the number of panels in the stack."""
+        return len(self._panels)
+
+    @property
+    def num_superimposed_panels(self) -> int:
+        """Get the number of superimposed panels in the stack."""
+        return len(self._superimposed_panels)
 
     @property
-    def fig(self) -> Figure:
+    def time_type(self) -> TimeType:
+        """The imposed time type on all time series panels in the stack.
+
+        :raises ValueError: If the `time_type` has not been set.
+        """
+        return self._time_type
+
+    @time_type.setter
+    def time_type(self, value: TimeType) -> None:
+        """Set the `TimeType` for all time series panels in the stack.
+
+        This controls how time is represented and annotated on the panel.
+
+        :param value: The `TimeType` to impose on all time series panels in the stack.
+        """
+        self._time_type = value
+
+    def _get_fig(self) -> Figure:
         """Get the shared `matplotlib` figure for the panel stack.
 
         :raises ValueError: If the axes have not been initialized.
@@ -88,8 +118,7 @@ class PanelStack:
             )
         return self._fig
 
-    @property
-    def axs(self) -> np.ndarray:
+    def _get_axes(self) -> np.ndarray:
         """Get the `matplotlib` axes in the stack.
 
         :return: An array of `matplotlib.axes.Axes`, one for each panel in the stack.
@@ -101,10 +130,13 @@ class PanelStack:
             )
         return np.atleast_1d(self._axs)
 
-    @property
-    def num_panels(self) -> int:
-        """Get the number of panels in the stack."""
-        return len(self._panels)
+    def _validate_time_type(self, panel: BasePanel) -> None:
+        """Check that the time type of the input panel, is consistent with the time type of the stack."""
+        if panel.get_time_type() != self._time_type:
+            raise ValueError(
+                f"Cannot add a panel with inconsistent time type. "
+                f"Expected {self._time_type.value}, but got {panel.get_time_type().value}"
+            )
 
     def add_panel(
         self,
@@ -114,13 +146,16 @@ class PanelStack:
     ) -> None:
         """Add a panel to the stack.
 
+        Overrides the time type of the panel, to the time type of the stack.
+
         :param panel: An instance of a `BasePanel` subclass to be added to the stack.
         :param identifier: An optional string to link the panel with others for superimposing.
         """
-        panel.panel_format = panel_format or self._panel_format
-        panel.time_type = self._time_type
+        panel.set_panel_format(panel_format or self._panel_format)
+        panel.set_time_type(self._time_type)
         if identifier:
-            panel.identifier = identifier
+            panel.set_identifier(identifier)
+
         self._panels.append(panel)
 
     def superimpose_panel(
@@ -131,13 +166,16 @@ class PanelStack:
     ) -> None:
         """Superimpose a panel onto an existing panel in the stack.
 
+        Overrides the time type of the panel, to the time type of the stack.
+
         :param panel: The panel to superimpose.
         :param identifier: An optional identifier to link panels during superimposing, defaults to None
         """
         if identifier:
-            panel.identifier = identifier
-        panel.panel_format = panel_format or self._panel_format
-        panel.time_type = self._time_type
+            panel.set_identifier(identifier)
+        panel.set_panel_format(panel_format or self._panel_format)
+        panel.set_time_type(self._time_type)
+
         self._superimposed_panels.append(panel)
 
     def _init_plot_style(self) -> None:
@@ -173,16 +211,17 @@ class PanelStack:
     def _assign_axes(self) -> None:
         """Assign each axes in the figure to some panel in the stack.
 
-        Axes are shared between panels with common `xaxis_type`.
+        Axes are shared between panels with common `XAxisType`.
         """
         shared_axes: dict[XAxisType, Axes] = {}
         for i, panel in enumerate(self.panels):
-            panel.ax = self.axs[i]
-            panel.fig = self._fig
+            ax = self._get_axes()[i]
+            panel.set_ax(ax)
+            panel.set_fig(self._fig)
             if panel.xaxis_type in shared_axes:
-                panel.ax.sharex(shared_axes[panel.xaxis_type])
+                panel.sharex(shared_axes[panel.xaxis_type])
             else:
-                shared_axes[panel.xaxis_type] = panel.ax
+                shared_axes[panel.xaxis_type] = ax
 
     def _overlay_cuts(self, cuts_panel: BasePanel) -> None:
         """Overlay cuts onto corresponding spectrogram panels.
@@ -210,9 +249,9 @@ class PanelStack:
         for super_panel in self._superimposed_panels:
             for panel in self._panels:
                 if panel.name == super_panel.name and (
-                    panel.identifier == super_panel.identifier
+                    panel.get_identifier() == super_panel.get_identifier()
                 ):
-                    super_panel.ax, super_panel.fig = panel.ax, self._fig
+                    super_panel.share_axes(panel)
                     super_panel.draw()
                     if _is_cuts_panel(super_panel):
                         self._overlay_cuts(super_panel)
@@ -245,7 +284,7 @@ class PanelStack:
     def show(self) -> None:
         """Display the panel stack figure."""
         self._make_figure()
-        plt.show()
+        self._get_fig().show()
 
     def save(
         self,
@@ -268,5 +307,7 @@ class PanelStack:
             get_batches_dir_path(start_dt.year, start_dt.month, start_dt.day),
             f"{batch_name}.png",
         )
-        plt.savefig(batch_file_path)
+        # If the parent directory does not exist, create it.
+        os.makedirs(os.path.dirname(batch_file_path), exist_ok=True)
+        self._get_fig().savefig(batch_file_path)
         return batch_file_path

spectre_core/plotting/_panels.py

@@ -2,16 +2,17 @@
 # This file is part of SPECTRE
 # SPDX-License-Identifier: GPL-3.0-or-later
 
-from typing import TypeVar, Tuple, Iterator, Optional
+from typing import TypeVar, Tuple, Iterator, Optional, Literal
 from datetime import datetime
 
 from matplotlib.colors import LogNorm
 from matplotlib import cm
+from matplotlib.colorbar import Colorbar
 import numpy as np
 import numpy.typing as npt
 
 from spectre_core.spectrograms import Spectrogram, FrequencyCut, TimeCut
-from ._base import BaseSpectrumPanel, BaseTimeSeriesPanel
+from ._base import BasePanel, BaseTimeSeriesPanel, XAxisType
 from ._panel_names import PanelName
 
 
@@ -36,7 +37,7 @@ def _bind_to_colors(
     return zip(values, rgbas)
 
 
-class FrequencyCutsPanel(BaseSpectrumPanel):
+class FrequencyCutsPanel(BasePanel):
     """
     Panel for visualising spectrogram data as frequency cuts.
 
@@ -73,6 +74,19 @@ class FrequencyCutsPanel(BaseSpectrumPanel):
         self._peak_normalise = peak_normalise
         self._frequency_cuts: dict[float | datetime, FrequencyCut] = {}
 
+    @property
+    def xaxis_type(self) -> Literal[XAxisType.FREQUENCY]:
+        return XAxisType.FREQUENCY
+
+    @property
+    def frequencies(self) -> npt.NDArray[np.float32]:
+        """The physical frequencies assigned to each spectral component."""
+        return self._spectrogram.frequencies
+
+    def annotate_xaxis(self) -> None:
+        """Annotate the x-axis assuming frequency in units of Hz."""
+        self._get_ax().set_xlabel("Frequency [Hz]")
+
     def get_frequency_cuts(self) -> dict[float | datetime, FrequencyCut]:
         """
         Get the frequency cuts for the specified times.
@@ -106,7 +120,7 @@ class FrequencyCutsPanel(BaseSpectrumPanel):
         frequency_cuts = self.get_frequency_cuts()
         for time, color in self.bind_to_colors():
             frequency_cut = frequency_cuts[time]
-            self.ax.step(
+            self._get_ax().step(
                 self.frequencies,  # convert to MHz
                 frequency_cut.cut,
                 where="mid",
@@ -119,13 +133,14 @@ class FrequencyCutsPanel(BaseSpectrumPanel):
         The y-axis label reflects whether the data is in decibels above the background (`dBb`),
         normalized to peak values, or in the original units of the spectrogram.
         """
+        ax = self._get_ax()
         if self._dBb:
-            self.ax.set_ylabel("dBb")
+            ax.set_ylabel("dBb")
         elif self._peak_normalise:
             # no y-axis label if we are peak normalising
             return
         else:
-            self.ax.set_ylabel(f"{self._spectrogram.spectrum_unit.value.capitalize()}")
+            ax.set_ylabel(f"{self._spectrogram.spectrum_unit.value.capitalize()}")
 
     def bind_to_colors(
         self,
@@ -137,7 +152,9 @@ class FrequencyCutsPanel(BaseSpectrumPanel):
 
         :return: An iterator of tuples, each containing a cut time and its corresponding RGBA color.
         """
-        return _bind_to_colors(self.get_cut_times(), cmap=self.panel_format.line_cmap)
+        return _bind_to_colors(
+            self.get_cut_times(), cmap=self.get_panel_format().line_cmap
+        )
 
 
 class TimeCutsPanel(BaseTimeSeriesPanel):
@@ -196,7 +213,7 @@ class TimeCutsPanel(BaseTimeSeriesPanel):
                     dBb=self._dBb,
                     peak_normalise=self._peak_normalise,
                     correct_background=self._background_subtract,
-                    return_time_type=self.time_type,
+                    return_time_type=self.get_time_type(),
                 )
                 self._time_cuts[time_cut.frequency] = time_cut
         return self._time_cuts
@@ -215,7 +232,7 @@ class TimeCutsPanel(BaseTimeSeriesPanel):
         time_cuts = self.get_time_cuts()
         for frequency, color in self.bind_to_colors():
             time_cut = time_cuts[frequency]
-            self.ax.step(self.times, time_cut.cut, where="mid", color=color)
+            self._get_ax().step(self.times, time_cut.cut, where="mid", color=color)
 
     def annotate_yaxis(self) -> None:
         """
@@ -224,12 +241,13 @@ class TimeCutsPanel(BaseTimeSeriesPanel):
         The y-axis label reflects whether the data is in decibels above the background (`dBb`),
         normalized to peak values, or in the original units of the spectrogram.
         """
+        ax = self._get_ax()
         if self._dBb:
-            self.ax.set_ylabel("dBb")
+            ax.set_ylabel("dBb")
         elif self._peak_normalise:
             return  # no y-axis label if we are peak normalising.
         else:
-            self.ax.set_ylabel(f"{self._spectrogram.spectrum_unit.value.capitalize()}")
+            ax.set_ylabel(f"{self._spectrogram.spectrum_unit.value.capitalize()}")
 
     def bind_to_colors(self) -> Iterator[Tuple[float, npt.NDArray[np.float32]]]:
         """
@@ -239,7 +257,9 @@ class TimeCutsPanel(BaseTimeSeriesPanel):
 
         :return: An iterator of tuples, each containing a frequency and its corresponding RGBA color.
         """
-        return _bind_to_colors(self.get_frequencies(), cmap=self.panel_format.line_cmap)
+        return _bind_to_colors(
+            self.get_frequencies(), cmap=self.get_panel_format().line_cmap
+        )
 
 
 class IntegralOverFrequencyPanel(BaseTimeSeriesPanel):
@@ -272,7 +292,9 @@ class IntegralOverFrequencyPanel(BaseTimeSeriesPanel):
             correct_background=self._background_subtract,
             peak_normalise=self._peak_normalise,
         )
-        self.ax.step(self.times, I, where="mid", color=self.panel_format.line_color)
+        self._get_ax().step(
+            self.times, I, where="mid", color=self.get_panel_format().line_color
+        )
 
     def annotate_yaxis(self):
         """This panel does not annotate the y-axis."""
@@ -320,19 +342,20 @@ class SpectrogramPanel(BaseTimeSeriesPanel):
         vmin = self._vmin or -1
         vmax = self._vmax or 2
 
+        ax = self._get_ax()
         # Plot the spectrogram
-        pcm = self.ax.pcolormesh(
+        pcm = ax.pcolormesh(
             self.times,
             self._spectrogram.frequencies,
             dynamic_spectra,
             vmin=vmin,
             vmax=vmax,
-            cmap=self.panel_format.spectrogram_cmap,
+            cmap=self.get_panel_format().spectrogram_cmap,
         )
 
         # Add colorbar
         cbar_ticks = np.linspace(vmin, vmax, 6)
-        cbar = self.fig.colorbar(pcm, ax=self.ax, ticks=cbar_ticks)
+        cbar = self._get_fig().colorbar(pcm, ax=ax, ticks=cbar_ticks)
         cbar.set_label("dBb")
 
     def _draw_normal(self) -> None:
@@ -352,11 +375,11 @@ class SpectrogramPanel(BaseTimeSeriesPanel):
             norm = None
 
         # Plot the spectrogram
-        self.ax.pcolormesh(
+        self._get_ax().pcolormesh(
             self.times,
             self._spectrogram.frequencies,
             dynamic_spectra,
-            cmap=self.panel_format.spectrogram_cmap,
+            cmap=self.get_panel_format().spectrogram_cmap,
             norm=norm,
         )
 
@@ -369,7 +392,7 @@ class SpectrogramPanel(BaseTimeSeriesPanel):
 
     def annotate_yaxis(self) -> None:
         """Annotate the yaxis, assuming units of Hz."""
-        self.ax.set_ylabel("Frequency [Hz]")
+        self._get_ax().set_ylabel("Frequency [Hz]")
         return
 
     def overlay_time_cuts(self, cuts_panel: TimeCutsPanel) -> None:
@@ -382,8 +405,8 @@ class SpectrogramPanel(BaseTimeSeriesPanel):
         :param cuts_panel: The `TimeCutsPanel` containing the cut frequencies to overlay.
         """
         for frequency, color in cuts_panel.bind_to_colors():
-            self.ax.axhline(
-                frequency, color=color, linewidth=self.panel_format.line_width
+            self._get_ax().axhline(
+                frequency, color=color, linewidth=self.get_panel_format().line_width
             )
 
     def overlay_frequency_cuts(self, cuts_panel: FrequencyCutsPanel) -> None:
@@ -396,4 +419,6 @@ class SpectrogramPanel(BaseTimeSeriesPanel):
         :param cuts_panel: The `FrequencyCutsPanel` containing the cut times to overlay.
         """
         for time, color in cuts_panel.bind_to_colors():
-            self.ax.axvline(time, color=color, linewidth=self.panel_format.line_width)
+            self._get_ax().axvline(
+                time, color=color, linewidth=self.get_panel_format().line_width
+            )

spectre_core/spectrograms/_spectrogram.py

@@ -120,7 +120,9 @@ class Spectrogram:
         self._frequencies = frequencies
         self._tag = tag
         self._spectrum_unit = spectrum_unit
-        self._start_datetime = np.datetime64(start_datetime)
+        self._start_datetime = (
+            np.datetime64(start_datetime) if start_datetime is not None else None
+        )
 
         # by default, the background is evaluated over the whole spectrogram
         self._start_background_index = 0
@@ -218,7 +220,7 @@ class Spectrogram:
         :raises AttributeError: If the start_datetime has not been set.
         """
         if self._start_datetime is None:
-            raise AttributeError(f"A start time has not been set.")
+            raise ValueError(f"A start time has not been set.")
         return self._start_datetime
 
     @property

{spectre_core-0.0.23.dist-info → spectre_core-0.0.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spectre-core
-Version: 0.0.23
+Version: 0.0.24
 Summary: The core Python package used by the spectre program. 
 Maintainer-email: Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE

{spectre_core-0.0.23.dist-info → spectre_core-0.0.24.dist-info}/RECORD

@@ -1,4 +1,4 @@
-spectre_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spectre_core/__init__.py,sha256=Hsh_-YQxbxSv8T4mjUwiFbG-w2HMgaXutAsG7XmKz3A,184
 spectre_core/exceptions.py,sha256=MJSUkuH8BYFt9zfv9m4dNISELEit6Sv_M4ifXHmeBGU,1167
 spectre_core/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 spectre_core/_file_io/__init__.py,sha256=H_-6xE-T3yUyywTe4hQn-oU5ACUumY1O-7Sp80EnKfQ,358
@@ -20,8 +20,8 @@ spectre_core/capture_configs/_pconstraints.py,sha256=2doJEr9ntR9NnVBGAfgZOYAD6TI
 spectre_core/capture_configs/_pnames.py,sha256=sidIsvVCjOuOLVu58vrG0PCBBNyfHugWKSGaJkJ4A68,1680
 spectre_core/capture_configs/_ptemplates.py,sha256=xo3qVF1bKMagK7myiDnUWU793qgmVbZ7UV_23CXtvYw,15504
 spectre_core/capture_configs/_pvalidators.py,sha256=3EuddlktB3bhSj6U92JLvT5D1VCBKGPIjkWiEFu-Fd4,9441
-spectre_core/config/__init__.py,sha256=NPv2CM13IZyq4_doxDluvgk9eq0WsbVUeT5-4yPKwzA,592
-spectre_core/config/_paths.py,sha256=RDrJL6LQFqUGMw0ABXiAUuyezxQXTFTPpXAsJKOElIE,4954
+spectre_core/config/__init__.py,sha256=wEZ7VXjwpKCsEYZOkdKcJLWJdPt-a7lDF5u-qbs_MCg,754
+spectre_core/config/_paths.py,sha256=vEg5sdFCS2HJ6QDtev1tGqthN1IXD0QofGC8JwAuLo4,4841
 spectre_core/config/_time_formats.py,sha256=yAnGweUfbnuEDTO-kGtljV1himVbEunBFA0n0Hv8cXo,823
 spectre_core/jobs/__init__.py,sha256=is9Ur36OL-iUcLCZ9SMGE_vuKW0yytL4zhNEKQx0LEI,380
 spectre_core/jobs/_duration.py,sha256=xjQ3fnN-dBcTZW8AjX073R8kNrM4HS1fROIMSvrUP6o,327
@@ -32,12 +32,12 @@ spectre_core/logs/_configure.py,sha256=y5R6vOl824KlNZVvYykYZ1qalIKbLO8BlSPtXxh-C
 spectre_core/logs/_decorators.py,sha256=M0wJwh6mxQhwq4Y9ORCRSFMpfi-pIzSK18hy8O9QedM,1173
 spectre_core/logs/_logs.py,sha256=rrC9D5C-mb1WguuqrdWLpMQATkSemV4ew69WsfQEDc4,6590
 spectre_core/logs/_process_types.py,sha256=Fm_aimKhSjO4kqQ8okpOsNT6VZlnkienFVdx6YhBtIc,490
-spectre_core/plotting/__init__.py,sha256=EQ9HYKyeRSH0u-8BfmIlfOOl4Zd0jDtQcTw3fkAUBgE,565
-spectre_core/plotting/_base.py,sha256=7qEfwa8480sVsDxYuQwzRND1CI_ETPRZdVok92p6woc,7983
+spectre_core/plotting/__init__.py,sha256=AGu9ooOhVmzeLY7BDN7yj1W6ej1G6VBliIga0WRZYu4,740
+spectre_core/plotting/_base.py,sha256=0lm_KhnexgXqrx7TfskHJiut-2KTyZ-CmBfujc2Yl4I,8783
 spectre_core/plotting/_format.py,sha256=ACpwfQw5raBAQLRvLBfwQto-Hqg9JsmrZ5eLqU-51Kg,1352
 spectre_core/plotting/_panel_names.py,sha256=XxWIOfQRs5hhas1X6q9vRarH06SWMC_Kv96Hy4r6jYY,799
-spectre_core/plotting/_panel_stack.py,sha256=diBjkyUD7oCyNi7JtP9Pg0SxRZ-IUAXAX0sFieo4iJk,9909
-spectre_core/plotting/_panels.py,sha256=uqmkF53y9IS111Ud6539HjNmqjihgzoNqGS-Pz-0Nn4,15225
+spectre_core/plotting/_panel_stack.py,sha256=R278vkhvDYKkyJxuhkyA8yEVy7v0rbpCQ6QwGduDBq4,11619
+spectre_core/plotting/_panels.py,sha256=9tk_ebpIN4ADx6vcauy-reUWg5gR_FYK9d_--_mG598,15982
 spectre_core/post_processing/__init__.py,sha256=jMIfEpEi1cH61nyZXXtUxYXxN1hinvWml1tdhhZrUEo,642
 spectre_core/post_processing/_base.py,sha256=cS7f0TRAbd_6vVG4dxngzdsftyq3py4PRXhEQWby-UE,6473
 spectre_core/post_processing/_factory.py,sha256=wpbB9wjw0Bhcxp02ORNtRwqOSVBLivLcwfg_s18XZg4,2227
@@ -68,12 +68,12 @@ spectre_core/receivers/plugins/gr/_usrp.py,sha256=0pyyW-Fn6rO1NlJXzXQswdJLdgbQxj
 spectre_core/spectrograms/__init__.py,sha256=olHW9pFhYg6-yCcLL6sP8C4noLwzgBGDOO9_RDyP6Cw,803
 spectre_core/spectrograms/_analytical.py,sha256=xW8Zm955ls-PqHBm9tf6nNyCWxrrhwZxUbPa4eXPbXs,11019
 spectre_core/spectrograms/_array_operations.py,sha256=AsBDmxFMnC3hYRP6QCFN65Fh0OLUAY7CeCx8kqPG2ks,7518
-spectre_core/spectrograms/_spectrogram.py,sha256=g0kelDpYfTKpgwCSCIlAdjJAdDeZ0HfK8GoZo8oeH-w,27132
+spectre_core/spectrograms/_spectrogram.py,sha256=k0Azaz1NRV-ls1NOrwb0TpKwwcpGzjxv-MFj-MTyXsE,27192
 spectre_core/spectrograms/_transform.py,sha256=S9V0dROKv3L8dg9EiPxR90XNeKaNmvbfZh66sFjETRo,11749
 spectre_core/wgetting/__init__.py,sha256=9QD-8DjYq0hbU7f-NQ_Cg-TLKNbq0E0PI3yWJXJoC4k,341
 spectre_core/wgetting/_callisto.py,sha256=eZyTG07WQic-w9STbx91bOYWhWFof85TX41WY5WrJg4,7148
-spectre_core-0.0.23.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-spectre_core-0.0.23.dist-info/METADATA,sha256=aBRiX_75UMG8txXmcODbRUhL8b2KOGE1L3yLke3HCyg,41951
-spectre_core-0.0.23.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-spectre_core-0.0.23.dist-info/top_level.txt,sha256=-UsyjpFohXgZpgcZ9QbVeXhsIyF3Am8RxNFNDV_Ta2Y,13
-spectre_core-0.0.23.dist-info/RECORD,,
+spectre_core-0.0.24.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+spectre_core-0.0.24.dist-info/METADATA,sha256=FH1RnPWWBhp8alZcUdZhNx8JoF1ov0qtRAZm57QPdjk,41951
+spectre_core-0.0.24.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+spectre_core-0.0.24.dist-info/top_level.txt,sha256=-UsyjpFohXgZpgcZ9QbVeXhsIyF3Am8RxNFNDV_Ta2Y,13
+spectre_core-0.0.24.dist-info/RECORD,,