spectre-core 0.0.1__py3-none-any.whl

spectre_core/plotting/base.py

@@ -0,0 +1,194 @@
+# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from abc import ABC, abstractmethod
+from typing import Optional
+import numpy as np
+
+from matplotlib import cm
+import matplotlib.dates as mdates
+from matplotlib.axes import Axes
+from matplotlib.figure import Figure
+
+from spectre_core.spectrograms.spectrogram import Spectrogram
+
+TIME_X_AXIS = "time"
+FREQUENCY_X_AXIS = "frequency"
+
+class BasePanel(ABC):
+    def __init__(self, 
+                 name: str,
+                 spectrogram: Spectrogram, 
+                 time_type: str = "seconds"):
+        self._name = name
+        self._spectrogram = spectrogram
+
+        self._validate_time_type(time_type)
+        self._time_type = time_type
+
+        self._x_axis_type: Optional[str] = None
+        self._set_x_axis_type()
+
+        self._ax: Optional[Axes] = None # defined while stacking
+        self._fig: Optional[Figure] = None # defined while stacking
+        self._identifier: Optional[str] = None # defined if specified by the user
+
+
+    @abstractmethod
+    def draw(self):
+        pass
+
+
+    @abstractmethod
+    def annotate_x_axis(self):
+        pass
+
+
+    @abstractmethod
+    def annotate_y_axis(self):
+        pass
+
+
+    @abstractmethod
+    def _set_x_axis_type(self):
+        """Required to allow for axes sharing in the stack"""
+        pass
+
+
+    @property
+    def spectrogram(self) -> Spectrogram:
+        return self._spectrogram
+    
+
+    @property
+    def tag(self) -> str:
+        return self._spectrogram.tag
+    
+
+    @property
+    def time_type(self) -> str:
+        return self._time_type
+    
+
+    @property
+    def name(self) -> str:
+        if self._name is None:
+            raise AttributeError(f"Name for this panel has not yet been set")
+        return self._name
+    
+
+    @name.setter
+    def name(self, value: str) -> None:
+        self._name = value
+    
+    
+    @property
+    def ax(self) -> Axes:
+        if self._ax is None:
+            raise AttributeError(f"Axes have not yet been set for this panel")
+        return self._ax
+    
+
+    @ax.setter
+    def ax(self, value: Axes) -> None:
+        self._ax = value
+
+
+    @property
+    def fig(self) -> Figure:
+        if self._fig is None:
+            raise AttributeError(f"Figure has not yet been set for this panel")
+        return self._fig
+    
+
+    @fig.setter
+    def fig(self, value: Figure) -> None:
+        self._fig = value
+    
+
+
+    @property
+    def x_axis_type(self) -> str:
+        if self._x_axis_type is None:
+            raise AttributeError(f"x-axis type has not been defined for this panel")
+        return self._x_axis_type
+    
+    @property
+    def identifier(self) -> Optional[str]:
+        return self._identifier
+    
+    
+    @identifier.setter
+    def identifier(self, value: str) -> None:
+        self._identifier = value
+
+
+    def _validate_time_type(self, 
+                            time_type: str):
+        valid_time_types = ["seconds", "datetimes"]
+        if time_type not in valid_time_types:
+            raise ValueError(f"Invalid time type. "
+                             f"Expected one of {valid_time_types} "
+                             f"but received {time_type}")
+    
+
+    def bind_to_colors(self, 
+                       values: np.ndarray, 
+                       cmap: str = "winter"): 
+        cmap = cm.get_cmap(cmap)
+        rgbas = cmap(np.linspace(0.1, 0.9, len(values)))
+        return zip(values, rgbas) # assign each RGBA array to each value
+    
+
+    def hide_x_axis_labels(self) -> None:
+        self.ax.tick_params(axis='x', labelbottom=False)
+
+
+    def hide_y_axis_labels(self) -> None:
+        self.ax.tick_params(axis='y', labelbottom=False)
+    
+
+class BaseTimeSeriesPanel(BasePanel):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+    
+
+    @property
+    def times(self):
+        return self.spectrogram.times if self.time_type == "seconds" else self.spectrogram.datetimes
+    
+
+    def annotate_x_axis(self):
+        if self.time_type == "seconds":
+            self.ax.set_xlabel('Time [s]')
+        else:
+            self.ax.set_xlabel('Time [UTC]')
+            self.ax.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M:%S'))
+        
+        
+    def _set_x_axis_type(self):
+        self._x_axis_type = TIME_X_AXIS
+
+
+
+class BaseSpectrumPanel(BasePanel):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+
+    @property
+    def frequencies(self):
+        return self._spectrogram.frequencies
+
+
+    def annotate_x_axis(self):
+        self.ax.set_xlabel('Frequency [MHz]')
+
+
+    def _set_x_axis_type(self):
+        self._x_axis_type = FREQUENCY_X_AXIS
+
+
+class CutsPanel(BasePanel):
+    """Convenience parent class for cuts"""

spectre_core/plotting/factory.py

@@ -0,0 +1,26 @@
+# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from spectre_core.spectrograms.spectrogram import Spectrogram
+from spectre_core.plotting.base import BasePanel
+from spectre_core.plotting.panel_register import panels
+from spectre_core.exceptions import PanelNotFoundError
+
+def get_panel(panel_name: str, 
+              spectrogram: Spectrogram,
+              time_type: str,
+              *args, 
+              **kwargs) -> BasePanel:
+   
+    Panel = panels.get(panel_name)
+    if Panel is None:
+        valid_panels = list(panels.keys())
+        raise PanelNotFoundError(f"Could not find panel with name {panel_name}. "
+                                 f"Expected one of {valid_panels}")
+    
+    return Panel(panel_name,
+                 spectrogram, 
+                 time_type,
+                 *args, 
+                 **kwargs)

spectre_core/plotting/format.py

@@ -0,0 +1,19 @@
+# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from dataclasses import dataclass
+
+@dataclass
+class DefaultFormats:
+    small_size: int = 18
+    medium_size: int = 21
+    large_size: int = 24
+    line_width: int = 3
+    style: str = "dark_background"
+    spectrogram_cmap: str = "gnuplot2"
+    cuts_cmap: str = "winter"
+    integral_over_frequency_color: str = "lime"
+
+
+DEFAULT_FORMATS = DefaultFormats()

spectre_core/plotting/library/__init__.py

@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from spectre_core.dynamic_imports import import_target_modules
+
+import_target_modules(__file__, __name__, "panel")

spectre_core/plotting/library/frequency_cuts/panel.py

@@ -0,0 +1,74 @@
+# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from typing import Optional
+from datetime import datetime
+
+from spectre_core.spectrograms.spectrogram import FrequencyCut
+from spectre_core.spectrograms.spectrogram import Spectrogram
+from spectre_core.plotting.base import BaseSpectrumPanel, CutsPanel
+from spectre_core.plotting.panel_register import register_panel
+from spectre_core.plotting.format import DEFAULT_FORMATS
+
+FREQUENCY_CUTS_PANEL_NAME = "frequency_cuts"
+
+@register_panel(FREQUENCY_CUTS_PANEL_NAME)
+class Panel(BaseSpectrumPanel, CutsPanel):
+    def __init__(self, 
+                 name: str,
+                 spectrogram: Spectrogram, 
+                 time_type: str = "seconds",
+                 *times: list[float | str],
+                 dBb: bool = False,
+                 peak_normalise: bool = False,
+                 cmap: str = DEFAULT_FORMATS.cuts_cmap,
+                 **kwargs):
+        super().__init__(name, 
+                         spectrogram, 
+                         time_type, 
+                         **kwargs)
+        self._times = times
+        self._cmap = cmap
+        self._dBb = dBb
+        self._peak_normalise = peak_normalise
+        # map each time cut to the corresponding FrequencyCut dataclass
+        self._frequency_cuts: Optional[dict[float | datetime, FrequencyCut]] = {}
+
+
+    @property
+    def frequency_cuts(self) -> dict[float | str, FrequencyCut]:
+        if not self._frequency_cuts:
+            for time in self._times:
+                frequency_cut = self._spectrogram.get_frequency_cut(time,
+                                                                    dBb = self._dBb,
+                                                                    peak_normalise = self._peak_normalise)
+                self._frequency_cuts[frequency_cut.time] = frequency_cut
+        return self._frequency_cuts
+
+
+    @property
+    def times(self) -> list[float | datetime]:
+        return list(self.frequency_cuts.keys())
+    
+
+    def draw(self):
+        for time, color in self.bind_to_colors():
+            frequency_cut = self.frequency_cuts[time]
+            self.ax.step(self.frequencies*1e-6, # convert to MHz
+                         frequency_cut.cut, 
+                         where='mid', 
+                         color = color)
+    
+
+    def annotate_y_axis(self) -> None:
+        if self._dBb:
+            self.ax.set_ylabel('dBb')
+        elif self._peak_normalise:
+            return # no y-axis label
+        else:
+            self.ax.set_ylabel(f'{self._spectrogram.spectrum_type.capitalize()}')
+
+    
+    def bind_to_colors(self):
+        return super().bind_to_colors(self.times, cmap = self._cmap)

spectre_core/plotting/library/integral_over_frequency/panel.py

@@ -0,0 +1,34 @@
+# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from spectre_core.plotting.base import BaseTimeSeriesPanel
+from spectre_core.plotting.panel_register import register_panel
+from spectre_core.plotting.format import DEFAULT_FORMATS
+
+INTEGRAL_OVER_FREQUENCY_PANEL_NAME = "integral_over_frequency"
+
+@register_panel(INTEGRAL_OVER_FREQUENCY_PANEL_NAME)
+class Panel(BaseTimeSeriesPanel):
+    def __init__(self, 
+                 *args, 
+                 peak_normalise: bool = False,
+                 background_subtract: bool = False,
+                 color: str = DEFAULT_FORMATS.integral_over_frequency_color,
+                 **kwargs):
+        super().__init__(*args, **kwargs)
+        self._peak_normalise = peak_normalise
+        self._background_subtract = background_subtract
+        self._color = color
+
+
+    def draw(self):
+        I = self._spectrogram.integrate_over_frequency(correct_background = self._background_subtract,
+                                                       peak_normalise = self._peak_normalise)
+        self.ax.step(self.times, I, where="mid", color = self._color)
+ 
+
+    def annotate_y_axis(self):
+        return # no y-axis label
+
+    

spectre_core/plotting/library/spectrogram/panel.py

@@ -0,0 +1,92 @@
+# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import numpy as np
+from matplotlib.colors import LogNorm
+from matplotlib.figure import Figure
+from matplotlib.axes import Axes
+from warnings import warn
+
+from spectre_core.plotting.base import BaseTimeSeriesPanel
+from spectre_core.plotting.panel_register import register_panel
+from spectre_core.plotting.base import CutsPanel
+from spectre_core.plotting.library.time_cuts.panel import Panel as TimeCutsPanel
+from spectre_core.plotting.library.frequency_cuts.panel import Panel as FrequencyCutsPanel
+from spectre_core.plotting.format import DEFAULT_FORMATS
+
+SPECTROGRAM_PANEL_NAME = "spectrogram"
+
+@register_panel(SPECTROGRAM_PANEL_NAME)
+class Panel(BaseTimeSeriesPanel):
+    def __init__(self, 
+                 *args, 
+                 log_norm: bool = False,
+                 dBb: bool = False,
+                 vmin: float | None = -1,
+                 vmax: float | None = 2,
+                 cmap: str = DEFAULT_FORMATS.spectrogram_cmap,
+                 **kwargs):
+        super().__init__(*args, **kwargs)
+        self._log_norm = log_norm
+        self._dBb = dBb
+        self._vmin = vmin
+        self._vmax = vmax
+        self._cmap = cmap
+
+
+    def draw(self):
+        dynamic_spectra = self._spectrogram.dynamic_spectra_as_dBb if self._dBb else self._spectrogram.dynamic_spectra
+
+        norm = LogNorm(vmin=np.nanmin(dynamic_spectra[dynamic_spectra > 0]), 
+                       vmax=np.nanmax(dynamic_spectra)) if self._log_norm else None
+        
+
+        if self._log_norm and (self._vmin or self._vmax):
+            warn("vmin/vmax will be ignored while using log_norm.")
+            self._vmin = None 
+            self._vmax = None
+        
+        # Plot the spectrogram with kwargs
+        pcm = self.ax.pcolormesh(self.times, 
+                            self._spectrogram.frequencies * 1e-6, 
+                            dynamic_spectra,
+                            vmin=self._vmin, 
+                            vmax=self._vmax,
+                            norm=norm, 
+                            cmap=self._cmap)
+        
+        # Add colorbar if dBb is used
+        if self._dBb:
+            cbar = self.fig.colorbar(pcm, 
+                                      ax=self.ax, 
+                                      ticks=np.linspace(self._vmin, self._vmax, 6, dtype=int))
+            cbar.set_label('dBb')
+
+
+    def annotate_y_axis(self) -> None:
+        self.ax.set_ylabel('Frequency [MHz]')
+        return
+    
+    
+    def overlay_cuts(self, cuts_panel: CutsPanel) -> None:
+        if isinstance(cuts_panel, TimeCutsPanel):
+            self._overlay_time_cuts(cuts_panel)
+        elif isinstance(cuts_panel, FrequencyCutsPanel):
+            self._overlay_frequency_cuts(cuts_panel)
+
+
+    def _overlay_time_cuts(self, time_cuts_panel: TimeCutsPanel) -> None:
+        for frequency, color in time_cuts_panel.bind_to_colors():
+            self.ax.axhline(frequency*1e-6, # convert to MHz
+                            color = color,
+                            linewidth=DEFAULT_FORMATS.line_width
+                            )
+            
+            
+    def _overlay_frequency_cuts(self, frequency_cuts_panel: FrequencyCutsPanel) -> None:
+        for time, color in frequency_cuts_panel.bind_to_colors():
+            self.ax.axvline(time,
+                            color = color,
+                            linewidth=DEFAULT_FORMATS.line_width
+                            )

spectre_core/plotting/library/time_cuts/panel.py

@@ -0,0 +1,77 @@
+# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from typing import Optional
+
+from spectre_core.spectrograms.spectrogram import TimeCut
+from spectre_core.spectrograms.spectrogram import Spectrogram
+from spectre_core.plotting.base import BaseTimeSeriesPanel, CutsPanel
+from spectre_core.plotting.format import DEFAULT_FORMATS
+from spectre_core.plotting.panel_register import register_panel
+
+TIME_CUTS_PANEL_NAME = "time_cuts"
+
+@register_panel(TIME_CUTS_PANEL_NAME)
+class Panel(BaseTimeSeriesPanel, CutsPanel):
+    def __init__(self, 
+                 name: str,
+                 spectrogram: Spectrogram, 
+                 time_type: str = "seconds",
+                 *frequencies: list[float],
+                 dBb: bool = False,
+                 peak_normalise: bool = False,
+                 background_subtract: bool = False,
+                 cmap: str = DEFAULT_FORMATS.cuts_cmap,
+                 **kwargs):
+        super().__init__(name, 
+                         spectrogram, 
+                         time_type, 
+                         **kwargs)
+        self._frequencies = frequencies
+        self._cmap = cmap
+        self._dBb = dBb
+        self._peak_normalise = peak_normalise
+        self._background_subtract = background_subtract
+        # map each cut frequency to the corresponding TimeCut dataclass
+        self._time_cuts: Optional[dict[float, TimeCut]] = {} 
+    
+
+    @property
+    def time_cuts(self) -> dict[float, TimeCut]:
+        if not self._time_cuts:
+            for frequency in self._frequencies:
+                time_cut =  self._spectrogram.get_time_cut(frequency,
+                                                           dBb = self._dBb,
+                                                           peak_normalise = self._peak_normalise,
+                                                           correct_background = self._background_subtract,
+                                                           return_time_type=self._time_type)
+                self._time_cuts[time_cut.frequency] = time_cut
+        return self._time_cuts
+    
+
+    @property
+    def frequencies(self) -> list[float]:
+        return list(self.time_cuts.keys())
+
+
+    def draw(self):
+        for frequency, color in self.bind_to_colors():
+            time_cut = self.time_cuts[frequency]
+            self.ax.step(self.times, 
+                         time_cut.cut, 
+                         where='mid', 
+                         color = color)
+    
+
+    def annotate_y_axis(self) -> None:
+        if self._dBb:
+            self.ax.set_ylabel('dBb')
+        elif self._peak_normalise:
+            return # no y-axis label
+        else:
+            self.ax.set_ylabel(f'{self._spectrogram.spectrum_type.capitalize()}')
+
+    
+    def bind_to_colors(self):
+        return super().bind_to_colors(self.frequencies, cmap = self._cmap)

spectre_core/plotting/panel_register.py

@@ -0,0 +1,13 @@
+# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+
+# Global dictionaries to hold the mappings
+panels = {}
+    
+def register_panel(panel_name: str): 
+    def decorator(cls):
+        panels[panel_name] = cls
+        return cls
+    return decorator

spectre_core/plotting/panel_stack.py

@@ -0,0 +1,148 @@
+# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import numpy as np
+from typing import List, Optional, Tuple
+import matplotlib.pyplot as plt
+from matplotlib.figure import Figure
+from matplotlib.axes import Axes
+
+from spectre_core.spectrograms.spectrogram import Spectrogram
+from spectre_core.plotting.base import BasePanel
+from spectre_core.plotting.factory import get_panel
+from spectre_core.plotting.library.time_cuts.panel import Panel as TimeCutsPanel
+from spectre_core.plotting.library.frequency_cuts.panel import Panel as FrequencyCutsPanel
+from spectre_core.plotting.library.spectrogram.panel import Panel as SpectrogramPanel
+from spectre_core.plotting.base import CutsPanel
+from spectre_core.plotting.format import DEFAULT_FORMATS
+
+class PanelStack:
+    def __init__(self, time_type: str, figsize: Tuple[int, int] = (10, 10)):
+        self._time_type = time_type
+        self._figsize = figsize
+        self._panels: List[BasePanel] = []
+        self._superimposed_panels: List[BasePanel] = []
+        self._fig: Optional[Figure] = None
+        self._axs: Optional[np.ndarray[Axes]] = None
+
+
+    @property
+    def time_type(self) -> str:
+        return self._time_type
+
+
+    @property
+    def panels(self) -> List[BasePanel]:
+        return sorted(self._panels, key=lambda panel: panel.x_axis_type)
+
+
+    @property
+    def fig(self) -> Optional[Figure]:
+        return self._fig
+
+
+    @property
+    def axs(self) -> Optional[np.ndarray[Axes]]:
+        return np.atleast_1d(self._axs)
+
+
+    @property
+    def num_panels(self) -> int:
+        return len(self._panels)
+
+
+    def add_panel(self, 
+                  panel_name: str, 
+                  spectrogram: Spectrogram,
+                  *args, 
+                  identifier: Optional[str] = None,
+                  **kwargs) -> None:
+        panel = get_panel(panel_name, 
+                          spectrogram, 
+                          self._time_type, 
+                          *args, 
+                          **kwargs)
+        if identifier: 
+            panel.identifier = identifier
+        self._panels.append(panel)
+
+
+    def superimpose_panel(self, 
+                          panel_name: str, 
+                          spectrogram: Spectrogram, 
+                          *args, 
+                          identifier: Optional[str] = None,
+                          **kwargs) -> None:
+        panel = get_panel(panel_name, 
+                          spectrogram, 
+                          self._time_type, 
+                          *args, 
+                          **kwargs)
+        if identifier:
+            panel.identifier = identifier
+        self._superimposed_panels.append(panel)
+
+
+    def _init_plot_style(self) -> None:
+        plt.style.use(DEFAULT_FORMATS.style)
+        plt.rc('font', size=DEFAULT_FORMATS.small_size)
+        plt.rc('axes', titlesize=DEFAULT_FORMATS.medium_size, 
+                       labelsize=DEFAULT_FORMATS.medium_size)
+        plt.rc('xtick', labelsize=DEFAULT_FORMATS.small_size)
+        plt.rc('ytick', labelsize=DEFAULT_FORMATS.small_size)
+        plt.rc('legend', fontsize=DEFAULT_FORMATS.small_size)
+        plt.rc('figure', titlesize=DEFAULT_FORMATS.large_size)
+
+
+    def _create_figure_and_axes(self) -> None:
+        self._fig, self._axs = plt.subplots(self.num_panels, 1, figsize=self._figsize, layout="constrained")
+
+
+    def _assign_axes(self) -> None:
+        shared_axes = {}
+        for i, panel in enumerate(self.panels):
+            panel.ax = self.axs[i]
+            panel.fig = self._fig
+            if panel.x_axis_type in shared_axes:
+                panel.ax.sharex(shared_axes[panel.x_axis_type])
+            else:
+                shared_axes[panel.x_axis_type] = panel.ax
+
+
+    def _overlay_cuts(self, cuts_panel: CutsPanel) -> None:
+        """Given a cuts panel, finds any corresponding spectrogram panels and adds the appropriate overlay"""
+        for panel in self.panels:
+            is_corresponding_panel = isinstance(panel, SpectrogramPanel) and (panel.tag == cuts_panel.tag)
+            if is_corresponding_panel:
+                panel.overlay_cuts(cuts_panel)
+
+
+    def _overlay_superimposed_panels(self) -> None:
+        for super_panel in self._superimposed_panels:
+            for panel in self._panels:
+                if panel.name == super_panel.name and (panel.identifier == super_panel.identifier): # find the matching panels via panel names
+                    super_panel.ax, super_panel.fig = panel.ax, self._fig # and superimpose via axes sharing
+                    super_panel.draw()
+                    if isinstance(super_panel, CutsPanel):
+                        self._overlay_cuts(super_panel)
+
+
+    def show(self) -> None:
+        self._init_plot_style()
+        self._create_figure_and_axes()
+        self._assign_axes()
+        last_panel_per_axis = {panel.x_axis_type: panel for panel in self.panels}
+        for panel in self.panels:
+            panel.draw()
+            panel.annotate_y_axis()
+            if panel == last_panel_per_axis[panel.x_axis_type]:
+                panel.annotate_x_axis()
+            else:
+                panel.hide_x_axis_labels()
+            if isinstance(panel, CutsPanel):
+                        self._overlay_cuts(panel)
+
+
+        self._overlay_superimposed_panels()
+        plt.show()

spectre_core/receivers/__init__.py

@@ -0,0 +1,6 @@
+# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+# dynamically import all receiver
+import spectre_core.receivers.library