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

spectre_core/logs/_logs.py

@@ -3,6 +3,7 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 from logging import getLogger
+
 _LOGGER = getLogger(__name__)
 
 import os
@@ -15,11 +16,8 @@ from spectre_core.config import get_logs_dir_path, TimeFormat
 from ._process_types import ProcessType
 
 
-def parse_log_base_file_name(
-    base_file_name: str
-) -> Tuple[str, str, str]:
-    """Parse the base file name of a log into a start time, process ID and process type.
-    """
+def parse_log_base_file_name(base_file_name: str) -> Tuple[str, str, str]:
+    """Parse the base file name of a log into a start time, process ID and process type."""
     file_name, _ = os.path.splitext(base_file_name)
     log_start_time, pid, process_type = file_name.split("_")
     return log_start_time, pid, process_type
@@ -27,12 +25,8 @@ def parse_log_base_file_name(
 
 class Log(TextHandler):
     """Interface to read log files generated by `spectre`."""
-    def __init__(
-        self, 
-        start_time: str, 
-        pid: str, 
-        process_type: ProcessType
-    ) -> None:
+
+    def __init__(self, start_time: str, pid: str, process_type: ProcessType) -> None:
         """Initialise a `Log` instance.
 
         :param start_time: The timestamp when the log file was created.
@@ -48,40 +42,32 @@ class Log(TextHandler):
         base_file_name = f"{start_time}_{pid}_{process_type.value}"
 
         super().__init__(parent_path, base_file_name, "log")
-    
 
     @property
-    def start_time(
-        self
-    ) -> str:
+    def start_time(self) -> str:
         """The system time when the log was created."""
         return self._start_time
-    
 
     @property
-    def pid(
-        self
-    ) -> str:
+    def pid(self) -> str:
         """The ID of the process writing to the log file."""
         return self._pid
-    
 
     @property
-    def process_type(
-        self
-    ) -> str:
+    def process_type(self) -> str:
         """Indicates the type of process, as defined by `ProcessType`."""
         return self._process_type
 
 
 class Logs:
     """Filter and read a collection of logs generated by `spectre`."""
+
     def __init__(
-        self, 
-        process_type: Optional[ProcessType] = None, 
-        year: Optional[int] = None, 
-        month: Optional[int] = None, 
-        day: Optional[int] = None
+        self,
+        process_type: Optional[ProcessType] = None,
+        year: Optional[int] = None,
+        month: Optional[int] = None,
+        day: Optional[int] = None,
     ) -> None:
         """Initialise a `Logs` instance.
 
@@ -91,81 +77,53 @@ class Logs:
         :param day: Filter by the numeric day. Defaults to None.
         """
         self._process_type = process_type.value if process_type is not None else None
-            
+
         self._log_map: dict[str, Log] = OrderedDict()
         self.set_date(year, month, day)
 
-
     @property
-    def process_type(
-        self
-    ) -> Optional[str]:
+    def process_type(self) -> Optional[str]:
         """Indicates the type of process, as defined by `ProcessType`."""
         return self._process_type
-    
 
     @property
-    def year(
-        self
-    ) -> Optional[int]:
+    def year(self) -> Optional[int]:
         """Filter by the numeric year."""
         return self._year
 
-
-    @property 
-    def month(
-        self
-    ) -> Optional[int]:
+    @property
+    def month(self) -> Optional[int]:
         """Filter by the numeric month."""
         return self._month
-    
 
     @property
-    def day(
-        self
-    ) -> Optional[int]:
+    def day(self) -> Optional[int]:
         """Filter by the numeric day."""
         return self._day
 
-
     @property
-    def logs_dir_path(
-        self
-    ) -> str:
+    def logs_dir_path(self) -> str:
         """The shared ancestral path for all the log files. `Logs` recursively searches
         this directory to find all log files according to the date and process type."""
         return get_logs_dir_path(self.year, self.month, self.day)
-        
 
     @property
-    def log_list(
-        self
-    ) -> list[Log]:
+    def log_list(self) -> list[Log]:
         """A list of all log handlers representing files found within `logs_dir_path`."""
         return list(self._log_map.values())
 
-
     @property
-    def num_logs(
-        self
-    ) -> int:
+    def num_logs(self) -> int:
         """The number of log files found within `logs_dir_path`."""
-        return len(self.log_list) 
-
+        return len(self.log_list)
 
     @property
-    def file_names(
-        self
-    ) -> list[str]:
+    def file_names(self) -> list[str]:
         """A list of all log file names found within `logs_dir_path`."""
         return list(self._log_map.keys())
 
-
     def set_date(
-        self, 
-        year: Optional[int],
-        month: Optional[int],
-        day: Optional[int]
+        self, year: Optional[int], month: Optional[int], day: Optional[int]
     ) -> None:
         """Reset `logs_dir_path` according to the numeric date, and refresh the list
         of available log files.
@@ -179,36 +137,28 @@ class Logs:
         self._day = day
         self.update()
 
-
-    def update(
-        self
-    ) -> None:
+    def update(self) -> None:
         """Perform a fresh search of all files in `logs_dir_path` for log files
         according to the date and process type."""
         log_files = [f for (_, _, files) in os.walk(self.logs_dir_path) for f in files]
 
         for log_file in log_files:
-            
+
             log_start_time, pid, process_type = parse_log_base_file_name(log_file)
 
             if self.process_type and process_type != self.process_type:
                 continue
 
-            self._log_map[log_file] = Log(log_start_time, pid, ProcessType(process_type))
+            self._log_map[log_file] = Log(
+                log_start_time, pid, ProcessType(process_type)
+            )
 
         self._log_map = OrderedDict(sorted(self._log_map.items()))
 
-
-    def __iter__(
-        self
-    ) -> Iterator[Log]:
+    def __iter__(self) -> Iterator[Log]:
         yield from self.log_list
 
-
-    def get_from_file_name(
-        self, 
-        file_name: str
-    ) -> Log:
+    def get_from_file_name(self, file_name: str) -> Log:
         """Retrieve a `Log` instance based on the log file name.
 
         :param file_name: The name of the log file (with or without extension).
@@ -220,13 +170,11 @@ class Logs:
         try:
             return self._log_map[file_name]
         except KeyError:
-            raise FileNotFoundError(f"Log handler for file name '{file_name}' not found in log map")
-
+            raise FileNotFoundError(
+                f"Log handler for file name '{file_name}' not found in log map"
+            )
 
-    def get_from_pid(
-        self, 
-        pid: str
-    ) -> Log:
+    def get_from_pid(self, pid: str) -> Log:
         """Retrieve a `Log` instance based on the process ID.
 
         :param pid: The process ID to search for.

spectre_core/logs/_process_types.py

@@ -4,11 +4,13 @@
 
 from enum import Enum
 
+
 class ProcessType(Enum):
     """The origin of a `spectre` process.
-    
+
     :ivar USER: A process is one initiated directly by the user, or part of the main user session.
     :ivar WORKER: A process is one which is created and managed internally by `spectre`.
     """
-    USER   = "user"
-    WORKER = "worker"
+
+    USER = "user"
+    WORKER = "worker"

spectre_core/plotting/__init__.py

@@ -5,9 +5,19 @@
 """An intuitive API for plotting spectrogram data."""
 
 from ._format import PanelFormat
-from ._panels import SpectrogramPanel, FrequencyCutsPanel, TimeCutsPanel, IntegralOverFrequencyPanel
+from ._panels import (
+    SpectrogramPanel,
+    FrequencyCutsPanel,
+    TimeCutsPanel,
+    IntegralOverFrequencyPanel,
+)
 from ._panel_stack import PanelStack
 
 __all__ = [
-    "PanelFormat", "PanelStack", "SpectrogramPanel", "FrequencyCutsPanel", "TimeCutsPanel", "IntegralOverFrequencyPanel"
-]
+    "PanelFormat",
+    "PanelStack",
+    "SpectrogramPanel",
+    "FrequencyCutsPanel",
+    "TimeCutsPanel",
+    "IntegralOverFrequencyPanel",
+]

spectre_core/plotting/_base.py

@@ -21,13 +21,14 @@ from ._panel_names import PanelName
 
 class XAxisType(Enum):
     """The x-axis type for a panel.
-    
+
     Axes are shared in a stack between panels with common `XAxisType`.
-    
+
     :ivar TIME: The xaxis has units of time.
     :ivar FREQUENCY: The xaxis has units of frequency.
     """
-    TIME      = "time"
+
+    TIME = "time"
     FREQUENCY = "frequency"
 
 
@@ -38,11 +39,8 @@ class BasePanel(ABC):
     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.
     """
-    def __init__(
-        self, 
-        name: PanelName,
-        spectrogram: Spectrogram
-    ) -> None:
+
+    def __init__(self, name: PanelName, spectrogram: Spectrogram) -> None:
         """Initialize an instance of `BasePanel`.
 
         :param name: The name of the panel.
@@ -53,61 +51,40 @@ class BasePanel(ABC):
 
         # internal attributes set by `PanelStack` during stacking.
         self._panel_format: Optional[PanelFormat] = None
-        self._time_type   : Optional[TimeType]    = None
-        self._ax          : Optional[Axes]        = None
-        self._fig         : Optional[Figure]      = None
-        self._identifier  : Optional[str]         = None
-
+        self._time_type: Optional[TimeType] = None
+        self._ax: Optional[Axes] = None
+        self._fig: Optional[Figure] = None
+        self._identifier: Optional[str] = None
 
     @abstractmethod
-    def draw(
-        self
-    ) -> None:
+    def draw(self) -> None:
         """Modify the `ax` attribute to draw the panel contents."""
 
-
     @abstractmethod
-    def annotate_xaxis(
-        self
-    ) -> None:
+    def annotate_xaxis(self) -> None:
         """Modify the `ax` attribute to annotate the x-axis of the panel."""
 
-
     @abstractmethod
-    def annotate_yaxis(
-        self
-    ) -> None:
+    def annotate_yaxis(self) -> None:
         """Modify the `ax` attribute to annotate the y-axis of the panel."""
 
-
     @property
     @abstractmethod
-    def xaxis_type(
-        self
-    ) -> XAxisType:
-     """Specify the x-axis type for the panel."""
-
+    def xaxis_type(self) -> XAxisType:
+        """Specify the x-axis type for the panel."""
 
     @property
-    def spectrogram(
-        self
-    ) -> Spectrogram:
+    def spectrogram(self) -> Spectrogram:
         """The spectrogram being visualised on this panel."""
         return self._spectrogram
-    
 
     @property
-    def tag(
-        self
-    ) -> str:
+    def tag(self) -> str:
         """The tag of the spectrogram being visualised."""
         return self._spectrogram.tag
-    
 
     @property
-    def time_type(
-        self
-    ) -> TimeType:
+    def time_type(self) -> TimeType:
         """The time type of the spectrogram.
 
         :raises ValueError: If the `time_type` has not been set.
@@ -115,13 +92,9 @@ class BasePanel(ABC):
         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 time_type(self, value: TimeType) -> None:
         """Set the `TimeType` for the spectrogram.
 
         This controls how time is represented and annotated on the panel.
@@ -129,20 +102,14 @@ class BasePanel(ABC):
         :param value: The `TimeType` to assign to the spectrogram.
         """
         self._time_type = value
-    
 
     @property
-    def name(
-        self
-    ) -> PanelName:
+    def name(self) -> PanelName:
         """The name of the panel."""
         return self._name
-    
-    
+
     @property
-    def panel_format(
-        self
-    ) -> PanelFormat:
+    def 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.
@@ -151,23 +118,16 @@ class BasePanel(ABC):
             raise ValueError(f"`panel_format` for the panel '{self.name}' must be set.")
         return self._panel_format
 
-
     @panel_format.setter
-    def panel_format(
-        self, 
-        value: PanelFormat
-    ) -> None:
+    def 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:
+    def ax(self) -> Axes:
         """The `Axes` object bound to this panel.
 
         :raises AttributeError: If the `Axes` object has not been set.
@@ -175,13 +135,9 @@ class BasePanel(ABC):
         if self._ax is None:
             raise AttributeError(f"`ax` must be set for the panel `{self.name}`")
         return self._ax
-    
 
     @ax.setter
-    def ax(
-        self, 
-        value: Axes
-    ) -> None:
+    def ax(self, value: Axes) -> None:
         """Assign a Matplotlib `Axes` object to this panel.
 
         This `Axes` will be used for drawing and annotations.
@@ -190,11 +146,8 @@ class BasePanel(ABC):
         """
         self._ax = value
 
-
     @property
-    def fig(
-        self
-    ) -> Figure:
+    def fig(self) -> Figure:
         """
         The `Figure` object bound to this panel.
 
@@ -203,13 +156,9 @@ class BasePanel(ABC):
         if self._fig is None:
             raise AttributeError(f"`fig` must be set for the panel `{self.name}`")
         return self._fig
-    
 
     @fig.setter
-    def fig(
-        self, 
-        value: Figure
-    ) -> None:
+    def fig(self, value: Figure) -> None:
         """
         Assign a Matplotlib `Figure` object to this panel.
 
@@ -218,104 +167,81 @@ class BasePanel(ABC):
         :param value: The Matplotlib `Figure` to assign to the panel.
         """
         self._fig = value
-    
-    
+
     @property
-    def identifier(
-        self
-    ) -> Optional[str]:
+    def identifier(self) -> Optional[str]:
         """Optional identifier for the panel.
 
-        This identifier can be used to distinguish panels or aid in superimposing 
+        This identifier can be used to distinguish panels or aid in superimposing
         panels in a stack.
         """
         return self._identifier
-    
-    
+
     @identifier.setter
-    def identifier(
-        self, 
-        value: str
-    ) -> None:
+    def identifier(self, value: str) -> None:
         """Set the optional identifier for the panel.
-        
+
         This can be used to distinguish panels or aid in superimposing panels.
         """
         self._identifier = value
-    
 
-    def hide_xaxis_labels(
-        self
-    ) -> None:
+    def hide_xaxis_labels(self) -> None:
         """Hide the x-axis labels for this panel."""
-        self.ax.tick_params(axis='x', labelbottom=False)
-
+        self.ax.tick_params(axis="x", labelbottom=False)
 
-    def hide_yaxis_labels(
-        self
-    ) -> None:
+    def hide_yaxis_labels(self) -> None:
         """Hide the y-axis labels for this panel."""
-        self.ax.tick_params(axis='y', labelbottom=False)
-    
+        self.ax.tick_params(axis="y", labelbottom=False)
+
 
 class BaseTimeSeriesPanel(BasePanel):
     """
     Abstract subclass of `BasePanel` designed for visualising time series data.
 
     Subclasses must implement any remaining abstract methods from `BasePanel`.
-    """   
+    """
+
     @property
-    def xaxis_type(
-        self
-    ) -> Literal[XAxisType.TIME]:
+    def xaxis_type(self) -> Literal[XAxisType.TIME]:
         return XAxisType.TIME
-    
-    
+
     @property
-    def times(
-        self
-    ) -> npt.NDArray[np.float32 | np.datetime64]:
+    def times(self) -> npt.NDArray[np.float32 | np.datetime64]:
         """The times assigned to each spectrum according to the `TimeType`."""
-        return self.spectrogram.times if self.time_type == TimeType.RELATIVE else self.spectrogram.datetimes
-    
+        return (
+            self.spectrogram.times
+            if self.time_type == TimeType.RELATIVE
+            else self.spectrogram.datetimes
+        )
 
-    def annotate_xaxis(
-        self
-    ) -> None:
+    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]')
+            self.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})')
+            # 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]:
+    def xaxis_type(self) -> Literal[XAxisType.FREQUENCY]:
         return XAxisType.FREQUENCY
-    
-    
+
     @property
-    def frequencies(
-        self
-    ) -> npt.NDArray[np.float32]:
+    def frequencies(self) -> npt.NDArray[np.float32]:
         """The physical frequencies assigned to each spectral component."""
         return self._spectrogram.frequencies
 
-
-    def annotate_xaxis(
-        self
-    ) -> None:
+    def annotate_xaxis(self) -> None:
         """Annotate the x-axis assuming frequency in units of Hz."""
-        self.ax.set_xlabel('Frequency [Hz]')
+        self.ax.set_xlabel("Frequency [Hz]")

spectre_core/plotting/_format.py

@@ -4,9 +4,10 @@
 
 from dataclasses import dataclass
 
+
 @dataclass
 class PanelFormat:
-    """Specifies formatting options for a panel, including font sizes, line styles, 
+    """Specifies formatting options for a panel, including font sizes, line styles,
     colour maps, and general visual settings.
 
     These formatting values can be applied consistently across all panels within a `PanelStack`,
@@ -21,11 +22,12 @@ class PanelFormat:
     :ivar style: Matplotlib style applied to the panel, defaults to "dark_background".
     :ivar spectrogram_cmap: Colormap applied to spectrogram plots, defaults to "gnuplot2".
     """
-    small_size      : int = 18
-    medium_size     : int = 21
-    large_size      : int = 24
-    line_width      : int = 3
-    line_color      : str = "lime"
-    line_cmap       : str = "winter"
-    style           : str = "dark_background"
+
+    small_size: int = 18
+    medium_size: int = 21
+    large_size: int = 24
+    line_width: int = 3
+    line_color: str = "lime"
+    line_cmap: str = "winter"
+    style: str = "dark_background"
     spectrogram_cmap: str = "gnuplot2"

spectre_core/plotting/_panel_names.py

@@ -4,15 +4,17 @@
 
 from enum import Enum
 
+
 class PanelName(Enum):
     """Literal corresponding to a fully implemented `BasePanel` subclass.
-    
+
     :ivar SPECTROGRAM: Panel for visualising the full spectrogram.
     :ivar FREQUENCY_CUTS: Panel for visualising individual spectrums in a spectrogram.
     :ivar TIME_CUTS: Panel for visualising spectrogram data as time series of spectral components.
     :ivar INTEGRAL_OVER_FREQUENCY: Panel for visualising the spectrogram integrated over frequency.
     """
-    SPECTROGRAM             = "spectrogram"
-    FREQUENCY_CUTS          = "frequency_cuts"
-    TIME_CUTS               = "time_cuts"
-    INTEGRAL_OVER_FREQUENCY = "integral_over_frequency"
+
+    SPECTROGRAM = "spectrogram"
+    FREQUENCY_CUTS = "frequency_cuts"
+    TIME_CUTS = "time_cuts"
+    INTEGRAL_OVER_FREQUENCY = "integral_over_frequency"