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

spectre_core/spectrograms/_analytical.py

@@ -52,14 +52,14 @@ class _AnalyticalFactory:
     def __init__(self) -> None:
         """Initialises an instance of the `_AnalyticalFactory` class."""
         self._builders: dict[str, Callable[[int, CaptureConfig], Spectrogram]] = {
-            "cosine_signal_1": self._cosine_signal_1,
-            "tagged_staircase": self._tagged_staircase,
+            "cosine_wave": self._cosine_wave,
+            "constant_staircase": self._constant_staircase,
         }
 
     @property
     def builders(self) -> dict[str, Callable[[int, CaptureConfig], Spectrogram]]:
         """
-        Provides a mapping from each `Test` receiver mode to its corresponding builder method.
+        Provides a mapping from each `SignalGenerator` receiver mode to its corresponding builder method.
 
         Each builder method generates the expected spectrograms for a session run in the associated mode.
         """
@@ -67,23 +67,23 @@ class _AnalyticalFactory:
 
     @property
     def test_modes(self) -> list[str]:
-        """Returns the available modes for the `Test` receiver."""
+        """Returns the available modes for the `SignalGenerator` receiver."""
         return list(self.builders.keys())
 
     def get_spectrogram(
         self, num_spectrums: int, capture_config: CaptureConfig
     ) -> Spectrogram:
         """
-        Generates an analytical spectrogram based on the capture config for a `Test` receiver.
+        Generates an analytical spectrogram based on the capture config for a `SignalGenerator` receiver.
 
         :param num_spectrums: The number of spectrums to include in the output spectrogram.
-        :param capture_config: The capture config used for `Test` receiver data capture.
-        :raises ValueError: Raised if the capture config is not associated with a `Test` receiver.
-        :raises ModeNotFoundError: Raised if the specified `Test` mode in the capture config lacks
+        :param capture_config: The capture config used for `SignalGenerator` receiver data capture.
+        :raises ValueError: Raised if the capture config is not associated with a `SignalGenerator` receiver.
+        :raises ModeNotFoundError: Raised if the specified `SignalGenerator` mode in the capture config lacks
         a corresponding builder method.
-        :return: The expected spectrogram for running a session with the `Test` receiver in the specified mode.
+        :return: The expected spectrogram for running a session with the `SignalGenerator` receiver in the specified mode.
         """
-        if capture_config.receiver_name != "test":
+        if capture_config.receiver_name != "signal_generator":
             raise ValueError(
                 f"Input capture config must correspond to the test receiver"
             )
@@ -95,10 +95,10 @@ class _AnalyticalFactory:
             )
         return builder_method(num_spectrums, capture_config)
 
-    def _cosine_signal_1(
+    def _cosine_wave(
         self, num_spectrums: int, capture_config: CaptureConfig
     ) -> Spectrogram:
-        """Creates the expected spectrogram for the `Test` receiver operating in the mode `cosine-signal-1`."""
+        """Creates the expected spectrogram for the `SignalGenerator` receiver operating in the mode `cosine_wave`."""
         # Extract necessary parameters from the capture config.
         window_size = cast(int, capture_config.get_parameter_value(PName.WINDOW_SIZE))
         sample_rate = cast(int, capture_config.get_parameter_value(PName.SAMPLE_RATE))
@@ -146,10 +146,10 @@ class _AnalyticalFactory:
             SpectrumUnit.AMPLITUDE,
         )
 
-    def _tagged_staircase(
+    def _constant_staircase(
         self, num_spectrums: int, capture_config: CaptureConfig
     ) -> Spectrogram:
-        """Creates the expected spectrogram for the `Test` receiver operating in the mode `tagged-staircase`."""
+        """Creates the expected spectrogram for the `SignalGenerator` receiver operating in the mode `constant_staircase`."""
         # Extract necessary parameters from the capture config.
         window_size = cast(int, capture_config.get_parameter_value(PName.WINDOW_SIZE))
         min_samples_per_step = cast(
@@ -217,15 +217,15 @@ class _AnalyticalFactory:
 def get_analytical_spectrogram(
     num_spectrums: int, capture_config: CaptureConfig
 ) -> Spectrogram:
-    """Each mode of the `Test` receiver generates a known synthetic signal. Based on this, we can
+    """Each mode of the `SignalGenerator` receiver generates a known synthetic signal. Based on this, we can
     derive an analytical solution that predicts the expected spectrogram for a session in that mode.
 
-    This function constructs the analytical spectrogram using the capture config for a `Test`
+    This function constructs the analytical spectrogram using the capture config for a `SignalGenerator`
     receiver operating in a specific mode.
 
     :param num_spectrums: The number of spectrums in the output spectrogram.
     :param capture_config: The capture config used for data capture.
-    :return: The expected, analytically derived spectrogram for the specified mode of the `Test` receiver.
+    :return: The expected, analytically derived spectrogram for the specified mode of the `SignalGenerator` receiver.
     """
     factory = _AnalyticalFactory()
     return factory.get_spectrogram(num_spectrums, capture_config)
@@ -234,7 +234,7 @@ def get_analytical_spectrogram(
 def validate_analytically(
     spectrogram: Spectrogram, capture_config: CaptureConfig, absolute_tolerance: float
 ) -> TestResults:
-    """Validate a spectrogram generated during sessions with a `Test` receiver operating
+    """Validate a spectrogram generated during sessions with a `SignalGenerator` receiver operating
     in a particular mode.
 
     :param spectrogram: The spectrogram to be validated.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spectre-core
-Version: 0.0.24
+Version: 0.0.26
 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.24.dist-info → spectre_core-0.0.26.dist-info}/RECORD

@@ -1,4 +1,4 @@
-spectre_core/__init__.py,sha256=Hsh_-YQxbxSv8T4mjUwiFbG-w2HMgaXutAsG7XmKz3A,184
+spectre_core/__init__.py,sha256=886XLvO2Z9Dnk4FKUsWgHA6m-yd4ulobVDdKN0_MczE,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
@@ -12,7 +12,7 @@ spectre_core/batches/plugins/_batch_keys.py,sha256=KbtKIMCQIay6ulvMtKE6cc_nwXeTy
 spectre_core/batches/plugins/_callisto.py,sha256=Y03rDG2mc9sboYMeB9WxXWgsp0MXKb1ZMUKKJbEJ26Q,5871
 spectre_core/batches/plugins/_iq_stream.py,sha256=exyROl9HKudLga6Ziz0QAe8ipPm6kj0wXgA8DevjeF4,11804
 spectre_core/capture_configs/__init__.py,sha256=IAdhXKUY8KDwl4xBj2NRtAhfgLPdMcSDdZysUIC_HYw,1859
-spectre_core/capture_configs/_capture_config.py,sha256=iWBc6B8lreEgf7wUaxM4-_KQBaepYvwU2B4IiYAeUH8,4224
+spectre_core/capture_configs/_capture_config.py,sha256=dRQxFutgvQ8GXmT7IMlIgi4rk05y7c_ECjdH9J_-MPg,4333
 spectre_core/capture_configs/_capture_modes.py,sha256=ESk-wb-yqUYgRSfl9HYJg01w03UwsS6kSSrkFKW9fNw,889
 spectre_core/capture_configs/_capture_templates.py,sha256=Y8i8_9voMTq0IbQVUt3wdhzXdr9p5naLMLPU0LNefwQ,9867
 spectre_core/capture_configs/_parameters.py,sha256=8SfNrfQD0JWpEqSJFNSQF4MFpzbPIvtfQXZgt_Sekgw,5318
@@ -36,7 +36,7 @@ spectre_core/plotting/__init__.py,sha256=AGu9ooOhVmzeLY7BDN7yj1W6ej1G6VBliIga0WR
 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=R278vkhvDYKkyJxuhkyA8yEVy7v0rbpCQ6QwGduDBq4,11619
+spectre_core/plotting/_panel_stack.py,sha256=-YvLkF6ykJqLvtnHzguDr_jt3Teavw341bok9b4yJBI,12028
 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
@@ -46,34 +46,33 @@ spectre_core/post_processing/_register.py,sha256=A0GkFiUVmD8DkqblxEiywMiDq00vPpI
 spectre_core/post_processing/plugins/_event_handler_keys.py,sha256=4Gs7xcr_TqefMbL_DDij1GhUtAdCoMmmGaonzftcAiM,610
 spectre_core/post_processing/plugins/_fixed_center_frequency.py,sha256=Bsq8uxEEQqxvR_Iot6rhr7qjz-I0Eb6sQ4WSiZvOYKI,4951
 spectre_core/post_processing/plugins/_swept_center_frequency.py,sha256=wxiKYWgD6vQMNbNtIDb9iMf8uXauoDTyOZcAhax0me4,19937
-spectre_core/receivers/__init__.py,sha256=bC01PtgD13yC2-a8_cKF3wuXX0rhLxOpkoUWdK6q-Qw,746
-spectre_core/receivers/_base.py,sha256=PYDikKZJLaNQkvCyXKgFj2L7ZNCVb-Tv5ZltocRW2ew,8875
-spectre_core/receivers/_factory.py,sha256=VKQ3LaBNwjQB4D0Lyu9to21_jNaky8RpTlcvCn-DPc0,1933
-spectre_core/receivers/_register.py,sha256=KhzhTWD0DKWRylvBYtd6ngLp74MF9d80x1xHaxMVlHk,1356
-spectre_core/receivers/_spec_names.py,sha256=TlQSBaBHg1I2IyQPBQH5dXyKObMj2CQLg3IZ3X6ZqGA,2332
+spectre_core/receivers/__init__.py,sha256=91JLTWPAe-UvXh4zpN2dw3p0TspL5w2IlU1OU-BRAdc,850
+spectre_core/receivers/_factory.py,sha256=CFyy2roBIpZEeeKuf6f1owVE_3IAmhuk2bYBNoFEgUE,2131
+spectre_core/receivers/_receiver.py,sha256=WJfTNdgLU_pplq98xxAtpFSvGJzjHo7Gtx4LloCR8mo,8936
+spectre_core/receivers/_register.py,sha256=j20Gb0CddcPlRSN5a74cwVpEdwqu9KMH-_p21pHDjWQ,1348
+spectre_core/receivers/_specs.py,sha256=iOYWRwDf8cH-z5TM7yhZtIVFRZPioUtn2DCVfW20nMo,3482
 spectre_core/receivers/plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spectre_core/receivers/plugins/_b200mini.py,sha256=uM9UkGyWpQxPnuyBjGCw1bBIjVrieZWkxjPqmm9EVck,2695
-spectre_core/receivers/plugins/_receiver_names.py,sha256=XMrRsLjZzim7Vd-fnt8wF-I-nZK5emkw2MdD_I3QV10,486
-spectre_core/receivers/plugins/_rsp1a.py,sha256=QyWsznQ9bqQQHp4-dT6hEb0kTGvwlqRaQle9zGAtkYA,2493
-spectre_core/receivers/plugins/_rspduo.py,sha256=6zJluOvGHU1tjXKMsq0AMjKnnc3Zf3fy4TzuvbCxkBM,3159
-spectre_core/receivers/plugins/_sdrplay_receiver.py,sha256=ovrJmTym8qffcyFszzQu_tS0kqTQB6-JEAkP2EEEk1k,5198
-spectre_core/receivers/plugins/_test.py,sha256=o5KXPaHWiC0g9IouJq7GrzcL-YZuT_lCJMv41yPj-7Q,8071
-spectre_core/receivers/plugins/_usrp.py,sha256=S-05BtvDekHro0Ldxo6oIDzZvlZYpNwqw7Wmn5NbgUQ,6998
-spectre_core/receivers/plugins/gr/__init__.py,sha256=ObN2dlX46k3YlRF0fpjPvELvwbNSVr_N98_qmHF8yXM,160
-spectre_core/receivers/plugins/gr/_base.py,sha256=dZ5sqRC1qSsbc-90eFUCkdM-WDjQXSFo7aBzN9L1Q20,2461
-spectre_core/receivers/plugins/gr/_rsp1a.py,sha256=uRl1HHkaLYX9DEiThQTyW-bTmCDrSHyPfinzT4MKnG0,5399
-spectre_core/receivers/plugins/gr/_rspduo.py,sha256=NgW0oxkpewvL6IJmgrXbnwORL5yn0c3rpmpl3RCC8-M,8637
-spectre_core/receivers/plugins/gr/_test.py,sha256=3WmvBgfxkeVCpiwGLOq1aTQHLIiLi4qPNu6-NEwq4U0,4551
-spectre_core/receivers/plugins/gr/_usrp.py,sha256=0pyyW-Fn6rO1NlJXzXQswdJLdgbQxjD5z1PHhbhXxnk,5687
+spectre_core/receivers/plugins/_b200mini.py,sha256=ob1aPIaQyNo6GFI6_fKuxDPfv9YAC1ImpDHZCLqTJwQ,8745
+spectre_core/receivers/plugins/_b200mini_gr.py,sha256=TR2quhuYFMsbpOM6ahMPhTLvWJc-Te3j_GZfOybwpkQ,4926
+spectre_core/receivers/plugins/_custom.py,sha256=XO_J0HBIBKfzpa1zm6qtDbqrbiH6cLUJhPT0CBsMg-0,623
+spectre_core/receivers/plugins/_gr.py,sha256=g0pLqCsiW1muaF17A9jAC8hhp6VR1m89NYCIOgwDvxc,2452
+spectre_core/receivers/plugins/_receiver_names.py,sha256=2grQdv76fdOGVQhJhtQOXhC22_Vu2zJ3EaSXTrmsit0,626
+spectre_core/receivers/plugins/_rsp1a.py,sha256=6vx4uFUxkC4-7kC7qxL7WFLW2v1cUsvHX6pNsWNMsqA,2340
+spectre_core/receivers/plugins/_rsp1a_gr.py,sha256=kI_Z8IoSdNP3AoQQGQrbcpeJctmA8WemWsQnm7oKEEk,4939
+spectre_core/receivers/plugins/_rspduo.py,sha256=BjpODVms24qyMDJ_N5sYH7oKzsaa2hdF8JixRSLDq5Q,2766
+spectre_core/receivers/plugins/_rspduo_gr.py,sha256=u-DSa_7wtCNEQkSqLMwC9d89C-rYOMImoH8xGGpCN-o,7517
+spectre_core/receivers/plugins/_sdrplay_receiver.py,sha256=OqjILmsC0JmT5n_XlF5TMjmtsGWSb7l9E1NndAuNiHg,9868
+spectre_core/receivers/plugins/_signal_generator.py,sha256=7-Vp60fqsfApWEvjcOqKpYAb-mAMaWPP4EGV3DUqnKE,7408
+spectre_core/receivers/plugins/_signal_generator_gr.py,sha256=e6gPj1KJJqMmIZJkvT7n5XaoU7TTBeL5TKJXf9N99zo,3358
 spectre_core/spectrograms/__init__.py,sha256=olHW9pFhYg6-yCcLL6sP8C4noLwzgBGDOO9_RDyP6Cw,803
-spectre_core/spectrograms/_analytical.py,sha256=xW8Zm955ls-PqHBm9tf6nNyCWxrrhwZxUbPa4eXPbXs,11019
+spectre_core/spectrograms/_analytical.py,sha256=YspKx8GfS8aFcCRhyLTTyCVHfM1WA7te2JwP8wN9Gq8,11166
 spectre_core/spectrograms/_array_operations.py,sha256=AsBDmxFMnC3hYRP6QCFN65Fh0OLUAY7CeCx8kqPG2ks,7518
 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.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,,
+spectre_core-0.0.26.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+spectre_core-0.0.26.dist-info/METADATA,sha256=ETJz8h_5EtRNtcCV22cS6AOv6J9FXh4ikHXe5ollR7g,41951
+spectre_core-0.0.26.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+spectre_core-0.0.26.dist-info/top_level.txt,sha256=-UsyjpFohXgZpgcZ9QbVeXhsIyF3Am8RxNFNDV_Ta2Y,13
+spectre_core-0.0.26.dist-info/RECORD,,

spectre_core/receivers/_base.py

@@ -1,242 +0,0 @@
-# SPDX-FileCopyrightText: © 2024-2025 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 Callable, Optional, Literal, overload, Any
-
-from spectre_core.exceptions import ModeNotFoundError
-from spectre_core.capture_configs import CaptureTemplate, Parameters, CaptureConfig
-from .plugins._receiver_names import ReceiverName
-from ._spec_names import SpecName
-
-
-class BaseReceiver(ABC):
-    """Abstract base class for software-defined radio receivers."""
-
-    def __init__(self, name: ReceiverName, mode: Optional[str] = None) -> None:
-        """Initialise an instance of `BaseReceiver`.
-
-        :param name: The name of the receiver.
-        :param mode: The initial active operating mode. Defaults to None.
-        """
-        self._name = name
-
-        self._specs: dict[SpecName, float | int | list[float | int]] = {}
-        self._add_specs()
-
-        self._capture_methods: dict[str, Callable[[str, Parameters], None]] = {}
-        self._add_capture_methods()
-
-        self._capture_templates: dict[str, CaptureTemplate] = {}
-        self._add_capture_templates()
-
-        self._pvalidators: dict[str, Callable[[Parameters], None]] = {}
-        self._add_pvalidators()
-
-        self._mode: Optional[str] = mode
-
-    @abstractmethod
-    def _add_specs(self) -> None:
-        """Subclasses must use `add_spec` to add hardware specifications."""
-
-    @abstractmethod
-    def _add_capture_methods(self) -> None:
-        """Subclasses must use `add_capture_method` to specify which method is called to capture
-        data, for each operating mode."""
-
-    @abstractmethod
-    def _add_capture_templates(self) -> None:
-        """Subclasses must use `add_capture_template` to define a `CaptureTemplate` for each operating mode."""
-
-    @abstractmethod
-    def _add_pvalidators(self) -> None:
-        """Subclasses must use `add_pvalidator` to add a parameter validation function (pvalidator)
-        for each operating mode."""
-
-    @property
-    def name(self) -> ReceiverName:
-        """The name of the receiver."""
-        return self._name
-
-    @property
-    def capture_methods(self) -> dict[str, Callable[[str, Parameters], None]]:
-        """For each operating mode, the method which is called to capture data."""
-        return self._capture_methods
-
-    @property
-    def capture_templates(self) -> dict[str, CaptureTemplate]:
-        """For each operating mode, the corresponding `CaptureTemplate`."""
-        return self._capture_templates
-
-    @property
-    def pvalidators(self) -> dict[str, Callable[[Parameters], None]]:
-        """For each operating mode, the corresponding parameter validation function (pvalidator)."""
-        return self._pvalidators
-
-    @property
-    def specs(self) -> dict[SpecName, float | int | list[float | int]]:
-        """The hardware specifications."""
-        return self._specs
-
-    @property
-    def modes(self) -> list[str]:
-        """The operating modes for the receiver.
-
-        :raises ValueError: If the modes are inconsistent between `capture_methods`,
-        `pvalidators` and `capture_templates`.
-        """
-        capture_method_modes = list(self.capture_methods.keys())
-        pvalidator_modes = list(self.pvalidators.keys())
-        capture_template_modes = list(self.capture_templates.keys())
-
-        if not capture_method_modes == pvalidator_modes == capture_template_modes:
-            raise ValueError(f"Mode mismatch for the receiver {self.name}.")
-        return capture_method_modes
-
-    @property
-    def mode(self) -> Optional[str]:
-        """The active operating mode for the receiver, if set."""
-        return self._mode
-
-    @mode.setter
-    def mode(self, value: str) -> None:
-        """Set the active operating mode.
-
-        :param value: The new operating mode to activate.
-        :raises ModeNotFoundError: If the specified mode is not defined in `modes`.
-        """
-        if value not in self.modes:
-            raise ModeNotFoundError(
-                f"{value} is not a defined mode for the receiver {self.name}. "
-                f"Expected one of {self.modes}"
-            )
-        self._mode = value
-
-    def _get_active_mode(self) -> str:
-        """Get the current mode, raising an error if none is set.
-
-        :raises ValueError: If no mode is currently set
-        :return: The current mode
-        """
-        if self._mode is None:
-            raise ValueError(
-                f"This operation requires an active mode for receiver `{self.name.value}`"
-            )
-        return self._mode
-
-    @property
-    def capture_method(self) -> Callable[[str, Parameters], None]:
-        """Start capturing data under the active operating mode."""
-        return self.capture_methods[self._get_active_mode()]
-
-    @property
-    def pvalidator(self) -> Callable[[Parameters], None]:
-        """The parameter validation function for the active operating mode."""
-        return self.pvalidators[self._get_active_mode()]
-
-    @property
-    def capture_template(self) -> CaptureTemplate:
-        """The `CaptureTemplate` for the active operating mode."""
-        return self._capture_templates[self._get_active_mode()]
-
-    def add_capture_method(
-        self, mode: str, capture_method: Callable[[str, Parameters], None]
-    ) -> None:
-        """
-        Add a capture method for a specific operating mode.
-
-        :param mode: The operating mode.
-        :param capture_method: The function which captures data.
-        """
-        self._capture_methods[mode] = capture_method
-
-    def add_pvalidator(
-        self, mode: str, pvalidator: Callable[[Parameters], None]
-    ) -> None:
-        """
-        Add a parameter validation function for a specific operating mode.
-
-        :param mode: The operating mode.
-        :param pvalidator: The validation function.
-        """
-        self._pvalidators[mode] = pvalidator
-
-    def add_capture_template(
-        self, mode: str, capture_template: CaptureTemplate
-    ) -> None:
-        """
-        Add a `CaptureTemplate` for a specific operating mode.
-
-        :param mode: The operating mode.
-        :param capture_template: The capture template, defining parameter requirements.
-        """
-        self._capture_templates[mode] = capture_template
-
-    def add_spec(self, name: SpecName, value: Any) -> None:
-        """
-        Add a hardware specification.
-
-        :param name: The specification's name.
-        :param value: The specification's value.
-        """
-        self.specs[name] = value
-
-    def get_spec(self, spec_name: SpecName) -> Any:
-        """
-        Retrieve a hardware specification.
-
-        :param spec_name: The name of the specification.
-        :raises KeyError: If the specification is not found.
-        :return: The specification's value.
-        """
-        if spec_name not in self.specs:
-            raise KeyError(
-                f"Spec not found with name '{spec_name}' "
-                f"for the receiver '{self.name}'"
-            )
-        return self.specs[spec_name]
-
-    def start_capture(self, tag: str) -> None:
-        """Start capturing data in the active operating mode.
-
-        :param tag: The tag of the capture config to load.
-        :raises ValueError: If no mode is currently set
-        """
-        active_mode = self._get_active_mode()
-        self.capture_methods[active_mode](tag, self.load_parameters(tag))
-
-    def save_parameters(
-        self, tag: str, parameters: Parameters, force: bool = False
-    ) -> None:
-        """Create a capture config according to the active operating mode and save the
-        input parameters.
-
-        :param tag: The tag identifying the capture config.
-        :param parameters: The parameters to save in the capture config.
-        :param force: If True, overwrites existing file if it exists.
-        :raises ValueError: If no mode is currently set
-        """
-        active_mode = self._get_active_mode()
-        parameters = self.capture_templates[active_mode].apply_template(parameters)
-        self.pvalidators[active_mode](parameters)
-
-        capture_config = CaptureConfig(tag)
-        capture_config.save_parameters(self.name.value, active_mode, parameters, force)
-
-    def load_parameters(self, tag: str) -> Parameters:
-        """Load a capture config, and return the parameters it stores.
-
-        :param tag: The tag identifying the capture config.
-        :raises ValueError: If no mode is currently set
-        :return: The validated parameters stored in the capture config.
-        """
-        active_mode = self._get_active_mode()
-        capture_config = CaptureConfig(tag)
-
-        parameters = self.capture_templates[active_mode].apply_template(
-            capture_config.parameters
-        )
-        self.pvalidators[active_mode](parameters)
-
-        return parameters

spectre_core/receivers/plugins/_test.py

@@ -1,225 +0,0 @@
-# SPDX-FileCopyrightText: © 2024-2025 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
-# This file is part of SPECTRE
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-from dataclasses import dataclass
-from typing import Callable, cast
-
-from spectre_core.capture_configs import (
-    CaptureTemplate,
-    CaptureMode,
-    Parameters,
-    Bound,
-    PName,
-    get_base_capture_template,
-    make_base_capture_template,
-    get_base_ptemplate,
-    validate_window,
-)
-from .gr._test import CaptureMethod
-from ._receiver_names import ReceiverName
-from .._spec_names import SpecName
-from .._base import BaseReceiver
-from .._register import register_receiver
-
-
-@dataclass(frozen=True)
-class Mode:
-    """An operating mode for the `Test` receiver."""
-
-    COSINE_SIGNAL_1 = "cosine_signal_1"
-    TAGGED_STAIRCASE = "tagged_staircase"
-
-
-@register_receiver(ReceiverName.TEST)
-class Test(BaseReceiver):
-    """An entirely software-defined receiver, which generates synthetic signals."""
-
-    def _add_specs(self) -> None:
-        self.add_spec(SpecName.SAMPLE_RATE_LOWER_BOUND, 64000)
-        self.add_spec(SpecName.SAMPLE_RATE_UPPER_BOUND, 640000)
-        self.add_spec(SpecName.FREQUENCY_LOWER_BOUND, 16000)
-        self.add_spec(SpecName.FREQUENCY_UPPER_BOUND, 160000)
-
-    def _add_capture_methods(self) -> None:
-        self.add_capture_method(Mode.COSINE_SIGNAL_1, CaptureMethod.cosine_signal_1)
-        self.add_capture_method(Mode.TAGGED_STAIRCASE, CaptureMethod.tagged_staircase)
-
-    def _add_pvalidators(self) -> None:
-        self.add_pvalidator(
-            Mode.COSINE_SIGNAL_1, self.__get_pvalidator_cosine_signal_1()
-        )
-        self.add_pvalidator(
-            Mode.TAGGED_STAIRCASE, self.__get_pvalidator_tagged_staircase()
-        )
-
-    def _add_capture_templates(self) -> None:
-        self.add_capture_template(
-            Mode.COSINE_SIGNAL_1, self.__get_capture_template_cosine_signal_1()
-        )
-        self.add_capture_template(
-            Mode.TAGGED_STAIRCASE, self.__get_capture_template_tagged_staircase()
-        )
-
-    def __get_capture_template_cosine_signal_1(self) -> CaptureTemplate:
-        capture_template = get_base_capture_template(CaptureMode.FIXED_CENTER_FREQUENCY)
-        capture_template.add_ptemplate(get_base_ptemplate(PName.AMPLITUDE))
-        capture_template.add_ptemplate(get_base_ptemplate(PName.FREQUENCY))
-
-        capture_template.set_defaults(
-            (PName.BATCH_SIZE, 3.0),
-            (PName.CENTER_FREQUENCY, 16000),
-            (PName.AMPLITUDE, 2.0),
-            (PName.FREQUENCY, 32000),
-            (PName.SAMPLE_RATE, 128000),
-            (PName.WINDOW_HOP, 512),
-            (PName.WINDOW_SIZE, 512),
-            (PName.WINDOW_TYPE, "boxcar"),
-        )
-
-        capture_template.enforce_defaults(
-            PName.TIME_RESOLUTION,
-            PName.TIME_RANGE,
-            PName.FREQUENCY_RESOLUTION,
-            PName.WINDOW_TYPE,
-        )
-
-        capture_template.add_pconstraint(
-            PName.SAMPLE_RATE,
-            [
-                Bound(
-                    lower_bound=self.get_spec(SpecName.SAMPLE_RATE_LOWER_BOUND),
-                    upper_bound=self.get_spec(SpecName.SAMPLE_RATE_UPPER_BOUND),
-                )
-            ],
-        )
-        capture_template.add_pconstraint(
-            PName.FREQUENCY,
-            [
-                Bound(
-                    lower_bound=self.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
-                    upper_bound=self.get_spec(SpecName.FREQUENCY_UPPER_BOUND),
-                )
-            ],
-        )
-        return capture_template
-
-    def __get_capture_template_tagged_staircase(self) -> CaptureTemplate:
-        capture_template = make_base_capture_template(
-            PName.TIME_RESOLUTION,
-            PName.FREQUENCY_RESOLUTION,
-            PName.TIME_RANGE,
-            PName.SAMPLE_RATE,
-            PName.BATCH_SIZE,
-            PName.WINDOW_TYPE,
-            PName.WINDOW_HOP,
-            PName.WINDOW_SIZE,
-            PName.EVENT_HANDLER_KEY,
-            PName.BATCH_KEY,
-            PName.WATCH_EXTENSION,
-            PName.MIN_SAMPLES_PER_STEP,
-            PName.MAX_SAMPLES_PER_STEP,
-            PName.FREQUENCY_STEP,
-            PName.STEP_INCREMENT,
-            PName.OBS_ALT,
-            PName.OBS_LAT,
-            PName.OBS_LON,
-            PName.OBJECT,
-            PName.ORIGIN,
-            PName.TELESCOPE,
-            PName.INSTRUMENT,
-        )
-
-        capture_template.set_defaults(
-            (PName.BATCH_SIZE, 3.0),
-            (PName.FREQUENCY_STEP, 128000),
-            (PName.MAX_SAMPLES_PER_STEP, 5000),
-            (PName.MIN_SAMPLES_PER_STEP, 4000),
-            (PName.SAMPLE_RATE, 128000),
-            (PName.STEP_INCREMENT, 200),
-            (PName.WINDOW_HOP, 512),
-            (PName.WINDOW_SIZE, 512),
-            (PName.WINDOW_TYPE, "boxcar"),
-            (PName.EVENT_HANDLER_KEY, "swept_center_frequency"),
-            (PName.BATCH_KEY, "iq_stream"),
-            (PName.WATCH_EXTENSION, "bin"),
-        )
-
-        capture_template.enforce_defaults(
-            PName.TIME_RESOLUTION,
-            PName.TIME_RANGE,
-            PName.FREQUENCY_RESOLUTION,
-            PName.WINDOW_TYPE,
-            PName.EVENT_HANDLER_KEY,
-            PName.BATCH_KEY,
-            PName.WATCH_EXTENSION,
-        )
-
-        return capture_template
-
-    def __get_pvalidator_cosine_signal_1(self) -> Callable[[Parameters], None]:
-        def pvalidator(parameters: Parameters) -> None:
-            validate_window(parameters)
-
-            sample_rate = cast(int, parameters.get_parameter_value(PName.SAMPLE_RATE))
-            window_size = cast(int, parameters.get_parameter_value(PName.WINDOW_SIZE))
-            frequency = cast(float, parameters.get_parameter_value(PName.FREQUENCY))
-
-            # check that the sample rate is an integer multiple of the underlying signal frequency
-            if sample_rate % frequency != 0:
-                raise ValueError(
-                    "The sampling rate must be some integer multiple of frequency"
-                )
-
-            a = sample_rate / frequency
-            if a < 2:
-                raise ValueError(
-                    (
-                        f"The ratio of sampling rate over frequency must be greater than two. "
-                        f"Got {a}"
-                    )
-                )
-
-            # analytical requirement
-            # if p is the number of sampled cycles, we can find that p = window_size / a
-            # the number of sampled cycles must be a positive natural number.
-            p = window_size / a
-            if window_size % a != 0:
-                raise ValueError(
-                    (
-                        f"The number of sampled cycles must be a positive natural number. "
-                        f"Computed that p={p}"
-                    )
-                )
-
-        return pvalidator
-
-    def __get_pvalidator_tagged_staircase(self) -> Callable[[Parameters], None]:
-        def pvalidator(parameters: Parameters) -> None:
-            validate_window(parameters)
-
-            freq_step = cast(
-                float, parameters.get_parameter_value(PName.FREQUENCY_STEP)
-            )
-            sample_rate = cast(int, parameters.get_parameter_value(PName.SAMPLE_RATE))
-            min_samples_per_step = cast(
-                int, parameters.get_parameter_value(PName.MIN_SAMPLES_PER_STEP)
-            )
-            max_samples_per_step = cast(
-                int, parameters.get_parameter_value(PName.MAX_SAMPLES_PER_STEP)
-            )
-
-            if freq_step != sample_rate:
-                raise ValueError(
-                    f"The frequency step must be equal to the sampling rate"
-                )
-
-            if min_samples_per_step > max_samples_per_step:
-                raise ValueError(
-                    (
-                        f"Minimum samples per step cannot be greater than the maximum samples per step. "
-                        f"Got {min_samples_per_step}, which is greater than {max_samples_per_step}"
-                    )
-                )
-
-        return pvalidator