spectre-core 0.0.12__py3-none-any.whl → 0.0.13__py3-none-any.whl

spectre_core/receivers/plugins/_rspduo.py

@@ -0,0 +1,67 @@
+# 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
+
+from ._receiver_names import ReceiverName
+from .gr._rspduo import CaptureMethod
+from .._spec_names import SpecName
+from ._sdrplay_receiver import SDRPlayReceiver
+from .._register import register_receiver
+
+
+@dataclass
+class Mode:
+    """An operating mode for the `RSPduo` receiver."""
+    TUNER_1_FIXED_CENTER_FREQUENCY  = f"tuner_1_fixed_center_frequency"
+    TUNER_2_FIXED_CENTER_FREQUENCY  = f"tuner_2_fixed_center_frequency"
+    TUNER_1_SWEPT_CENTER_FREQUENCY  = f"tuner_1_swept_center_frequency"
+
+
+@register_receiver(ReceiverName.RSPDUO)
+class RSPduo(SDRPlayReceiver):
+    """Receiver implementation for the SDRPlay RSPduo (https://www.sdrplay.com/rspduo/)"""
+    def _add_specs(self) -> None:
+        self.add_spec( SpecName.SAMPLE_RATE_LOWER_BOUND, 200e3     )
+        self.add_spec( SpecName.SAMPLE_RATE_UPPER_BOUND, 10e6      )
+        self.add_spec( SpecName.FREQUENCY_LOWER_BOUND  , 1e3       )
+        self.add_spec( SpecName.FREQUENCY_UPPER_BOUND  , 2e9       )
+        self.add_spec( SpecName.IF_GAIN_UPPER_BOUND    , -20       )
+        self.add_spec( SpecName.RF_GAIN_UPPER_BOUND    , 0         )
+        self.add_spec( SpecName.API_RETUNING_LATENCY   , 50 * 1e-3 )
+        self.add_spec( SpecName.BANDWIDTH_OPTIONS, 
+                      [200000, 300000, 600000, 1536000, 5000000, 6000000, 7000000, 8000000])
+
+
+    def _add_capture_methods(
+        self
+    ) -> None:
+        self.add_capture_method(Mode.TUNER_1_FIXED_CENTER_FREQUENCY, 
+                                CaptureMethod.tuner_1_fixed_center_frequency)
+        self.add_capture_method(Mode.TUNER_2_FIXED_CENTER_FREQUENCY, 
+                                CaptureMethod.tuner_2_fixed_center_frequency)
+        self.add_capture_method(Mode.TUNER_1_SWEPT_CENTER_FREQUENCY, 
+                                CaptureMethod.tuner_1_swept_center_frequency)
+    
+
+    def _add_capture_templates(
+        self
+    ) -> None:
+        self.add_capture_template(Mode.TUNER_1_FIXED_CENTER_FREQUENCY,
+                                  self._get_capture_template_fixed_center_frequency())
+        self.add_capture_template(Mode.TUNER_2_FIXED_CENTER_FREQUENCY,
+                                  self._get_capture_template_fixed_center_frequency())
+        self.add_capture_template(Mode.TUNER_1_SWEPT_CENTER_FREQUENCY,
+                                  self._get_capture_template_swept_center_frequency())
+        
+    
+    def _add_pvalidators(
+        self
+    ) -> None:
+        self.add_pvalidator(Mode.TUNER_1_FIXED_CENTER_FREQUENCY,
+                            self._get_pvalidator_fixed_center_frequency())
+        self.add_pvalidator(Mode.TUNER_2_FIXED_CENTER_FREQUENCY,
+                            self._get_pvalidator_fixed_center_frequency())
+        self.add_pvalidator(Mode.TUNER_1_SWEPT_CENTER_FREQUENCY,
+                            self._get_pvalidator_swept_center_frequency())

spectre_core/receivers/plugins/_sdrplay_receiver.py

@@ -0,0 +1,190 @@
+# 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 Callable, overload
+
+from spectre_core.capture_configs import (
+    CaptureTemplate, CaptureMode, Parameters, Bound, PName,
+    get_base_capture_template, get_base_ptemplate, OneOf,
+    validate_fixed_center_frequency, validate_swept_center_frequency
+)
+from .._base import BaseReceiver
+from .._spec_names import SpecName
+
+class SDRPlayReceiver(BaseReceiver):
+    """An abstract base class for SDRPlay receivers.
+    
+    Includes ready-to-go pvalidators and capture templates which are shared by all subclasses. 
+    Each subclasses must define the following hardware specifications:
+    
+    .. code-block:: python
+        def _add_specs(self) -> None:
+            self.add_spec( SpecName.SAMPLE_RATE_LOWER_BOUND, <TBD> )
+            self.add_spec( SpecName.SAMPLE_RATE_UPPER_BOUND, <TBD> )
+            self.add_spec( SpecName.FREQUENCY_LOWER_BOUND  , <TBD> )
+            self.add_spec( SpecName.FREQUENCY_UPPER_BOUND  , <TBD> )
+            self.add_spec( SpecName.IF_GAIN_UPPER_BOUND    , <TBD> )
+            self.add_spec( SpecName.RF_GAIN_UPPER_BOUND    , <TBD> )
+            self.add_spec( SpecName.API_RETUNING_LATENCY   , <TBD> )
+            self.add_spec( SpecName.BANDWIDTH_OPTIONS      , <TBD> )
+    """  
+    def _get_pvalidator_fixed_center_frequency(
+        self
+    ) -> Callable[[Parameters], None]:
+        def pvalidator(parameters: Parameters):
+            validate_fixed_center_frequency(parameters)
+        return pvalidator
+
+
+    def _get_pvalidator_swept_center_frequency(
+        self
+    ) -> Callable[[Parameters], None]:
+        def pvalidator(parameters: Parameters):
+            validate_swept_center_frequency(parameters,
+                                            self.get_spec(SpecName.API_RETUNING_LATENCY))
+        return pvalidator
+
+
+    def _get_capture_template_fixed_center_frequency(
+        self
+    ) -> CaptureTemplate:
+        
+        capture_template = get_base_capture_template( CaptureMode.FIXED_CENTER_FREQUENCY )
+        capture_template.add_ptemplate( get_base_ptemplate(PName.BANDWIDTH) )
+        capture_template.add_ptemplate( get_base_ptemplate(PName.IF_GAIN) )
+        capture_template.add_ptemplate( get_base_ptemplate(PName.RF_GAIN) )
+
+        capture_template.set_defaults(
+            (PName.BATCH_SIZE,            3.0),
+            (PName.CENTER_FREQUENCY,      95800000),
+            (PName.SAMPLE_RATE,           600000),
+            (PName.BANDWIDTH,             600000),
+            (PName.WINDOW_HOP,            512),
+            (PName.WINDOW_SIZE,           1024),
+            (PName.WINDOW_TYPE,           "blackman"),
+            (PName.RF_GAIN,               -30),
+            (PName.IF_GAIN,               -30)
+        )   
+
+        capture_template.add_pconstraint(
+            PName.CENTER_FREQUENCY,
+            [
+                Bound(
+                    lower_bound=self.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
+                    upper_bound=self.get_spec(SpecName.FREQUENCY_UPPER_BOUND)
+                )
+            ]
+        )
+        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.BANDWIDTH,
+            [
+                OneOf(
+                    self.get_spec( SpecName.BANDWIDTH_OPTIONS )
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PName.IF_GAIN,
+            [
+                Bound(
+                    upper_bound=self.get_spec(SpecName.IF_GAIN_UPPER_BOUND)
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PName.RF_GAIN,
+            [
+                Bound(
+                    upper_bound=self.get_spec(SpecName.RF_GAIN_UPPER_BOUND)
+                )
+            ]
+        )
+        return capture_template
+
+
+    def _get_capture_template_swept_center_frequency(
+        self
+    ) -> CaptureTemplate:
+
+        capture_template = get_base_capture_template( CaptureMode.SWEPT_CENTER_FREQUENCY )
+        capture_template.add_ptemplate( get_base_ptemplate(PName.BANDWIDTH) )
+        capture_template.add_ptemplate( get_base_ptemplate(PName.IF_GAIN) )
+        capture_template.add_ptemplate( get_base_ptemplate(PName.RF_GAIN) )
+
+        capture_template.set_defaults(
+            (PName.BATCH_SIZE,            4.0),
+            (PName.MIN_FREQUENCY,         95000000),
+            (PName.MAX_FREQUENCY,         100000000),
+            (PName.SAMPLES_PER_STEP,      80000),
+            (PName.FREQUENCY_STEP,        1536000),
+            (PName.SAMPLE_RATE,           1536000),
+            (PName.BANDWIDTH,             1536000),
+            (PName.WINDOW_HOP,            512),
+            (PName.WINDOW_SIZE,           1024),
+            (PName.WINDOW_TYPE,           "blackman"),
+            (PName.RF_GAIN,               -30),
+            (PName.IF_GAIN,               -30)
+        )   
+
+        capture_template.add_pconstraint(
+            PName.MIN_FREQUENCY,
+            [
+                Bound(
+                    lower_bound=self.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
+                    upper_bound=self.get_spec(SpecName.FREQUENCY_UPPER_BOUND)
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PName.MAX_FREQUENCY,
+            [
+                Bound(
+                    lower_bound=self.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
+                    upper_bound=self.get_spec(SpecName.FREQUENCY_UPPER_BOUND)
+                )
+            ]
+        )
+        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.BANDWIDTH,
+            [
+                OneOf(
+                    self.get_spec( SpecName.BANDWIDTH_OPTIONS )
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PName.IF_GAIN,
+            [
+                Bound(
+                    upper_bound=self.get_spec(SpecName.IF_GAIN_UPPER_BOUND)
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PName.RF_GAIN,
+            [
+                Bound(
+                    upper_bound=self.get_spec(SpecName.RF_GAIN_UPPER_BOUND)
+                )
+            ]
+        )
+        return capture_template

spectre_core/receivers/plugins/_test.py

@@ -0,0 +1,218 @@
+# 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
+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
+        

spectre_core/receivers/plugins/gr/_base.py

@@ -0,0 +1,80 @@
+# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import sys
+import signal
+from typing import Type, TypeVar
+
+from gnuradio import gr
+
+from spectre_core.capture_configs import Parameters
+
+class spectre_top_block(gr.top_block):
+    """A thin wrapper around GNU Radio's `gr.top_block` class.
+    
+    Propagate through the input tag and parameters to `flowgraph` in the constructor,
+    to make the GNU Radio flow graphs easily configurable.
+    """
+    def flowgraph(
+        self,
+        tag: str,
+        parameters: Parameters
+    ) -> None:
+        """Define the flowgraph for the block.
+        
+        This method uses inline imports to allow the `spectre_core.receivers` 
+        module to work without requiring all Out-Of-Tree (OOT) modules to be installed. 
+        Only import the necessary OOT modules when implementing this method.
+        """
+        raise NotImplementedError()
+        
+        
+    def __init__(
+        self,
+        tag: str,
+        parameters: Parameters
+    ) -> None:
+        """Create an instance of `spectre_top_block`.
+
+        :param tag: The capture config tag.
+        :param parameters: The capture config parameters
+        """
+        gr.top_block.__init__(self)
+        self.flowgraph(tag, parameters)
+
+
+def capture(
+    tag: str,
+    parameters: Parameters,
+    top_block_cls: Type[spectre_top_block],
+    max_noutput_items: int = 10000000
+) -> None:
+    """
+    Run a GNU Radio flowgraph with the given number of output items.
+
+    Typically, this should be used with `partial` from `functools` to create
+    a capture method. For example, 
+
+    .. code-block:: python
+        capture_method = partial(capture, top_block_cls=<your GNU Radio top block>)
+    
+    :param tag: The capture config tag
+    :param parameters: The parameters stored in the capture config
+    :param top_block_cls: The subclass of `spectre_top_block`, defining the GNURadio flowgraph.
+    :param max_noutput_items: The number of max `noutput_items` in the flowgraph. This controls
+    the maximum number of output items any block will handle during a call to work. Defaults to 10000000
+    (which has been chosen as per GNU Radio source code).
+    """
+    tb = top_block_cls(tag,
+                       parameters)
+
+    def sig_handler(sig=None, frame=None):
+        tb.stop()
+        tb.wait()
+        sys.exit(0)
+
+    signal.signal(signal.SIGINT, sig_handler)
+    signal.signal(signal.SIGTERM, sig_handler)
+
+    tb.run(max_noutput_items)

spectre_core/receivers/{gr → plugins/gr}/_rsp1a.py

@@ -19,34 +19,30 @@
 from functools import partial
 from dataclasses import dataclass
 
-from gnuradio import gr
-from gnuradio import spectre
-from gnuradio import sdrplay3
-
-from spectre_core.capture_configs import Parameters, PNames
+from spectre_core.capture_configs import Parameters, PName
 from spectre_core.config import get_batches_dir_path
-from ._base import capture
-
-class _fixed_center_frequency(gr.top_block):
-    def __init__(self, 
-                 tag: str,
-                 parameters: Parameters):
-        gr.top_block.__init__(self, catch_exceptions=True)
-
-        ##################################################
-        # Unpack capture config
-        ##################################################
-        sample_rate = parameters.get_parameter_value(PNames.SAMPLE_RATE)
-        batch_size  = parameters.get_parameter_value(PNames.BATCH_SIZE)
-        center_freq = parameters.get_parameter_value(PNames.CENTER_FREQUENCY)
-        bandwidth   = parameters.get_parameter_value(PNames.BANDWIDTH)
-        if_gain     = parameters.get_parameter_value(PNames.IF_GAIN)
-        rf_gain     = parameters.get_parameter_value(PNames.RF_GAIN)
+from ._base import capture, spectre_top_block
+
+class _fixed_center_frequency(spectre_top_block):
+    def flowgraph(
+        self, 
+        tag: str,
+        parameters: Parameters
+    ) -> None:
+        # OOT Module inline imports 
+        from gnuradio import spectre
+        from gnuradio import sdrplay3
+
+        # Unpack the capture config parameters
+        sample_rate = parameters.get_parameter_value(PName.SAMPLE_RATE)
+        batch_size  = parameters.get_parameter_value(PName.BATCH_SIZE)
+        center_freq = parameters.get_parameter_value(PName.CENTER_FREQUENCY)
+        bandwidth   = parameters.get_parameter_value(PName.BANDWIDTH)
+        if_gain     = parameters.get_parameter_value(PName.IF_GAIN)
+        rf_gain     = parameters.get_parameter_value(PName.RF_GAIN)
         
 
-        ##################################################
         # Blocks
-        ##################################################
         self.spectre_batched_file_sink_0 = spectre.batched_file_sink(get_batches_dir_path(), 
                                                                      tag, 
                                                                      batch_size, 
@@ -75,36 +71,33 @@ class _fixed_center_frequency(gr.top_block):
         self.sdrplay3_rsp1a_0.set_sample_sequence_gaps_check(False)
         self.sdrplay3_rsp1a_0.set_show_gain_changes(False)
 
-
-        ##################################################
         # Connections
-        ##################################################
         self.connect((self.sdrplay3_rsp1a_0, 0), (self.spectre_batched_file_sink_0, 0))
 
 
-class _swept_center_frequency(gr.top_block):
-    def __init__(self, 
-                 tag: str,
-                 parameters: Parameters):
-        gr.top_block.__init__(self, catch_exceptions=True)
+class _swept_center_frequency(spectre_top_block):
+    def flowgraph(
+        self, 
+        tag: str,
+        parameters: Parameters
+    ) -> None:
+        # OOT Module inline imports 
+        from gnuradio import spectre
+        from gnuradio import sdrplay3
+
+        # Unpack the capture config parameters
+        sample_rate      = parameters.get_parameter_value(PName.SAMPLE_RATE)
+        bandwidth        = parameters.get_parameter_value(PName.BANDWIDTH)
+        min_frequency    = parameters.get_parameter_value(PName.MIN_FREQUENCY)
+        max_frequency    = parameters.get_parameter_value(PName.MAX_FREQUENCY)
+        frequency_step   = parameters.get_parameter_value(PName.FREQUENCY_STEP)
+        samples_per_step = parameters.get_parameter_value(PName.SAMPLES_PER_STEP)
+        if_gain          = parameters.get_parameter_value(PName.IF_GAIN)
+        rf_gain          = parameters.get_parameter_value(PName.RF_GAIN)
+        batch_size       = parameters.get_parameter_value(PName.BATCH_SIZE)
 
-        ##################################################
-        # Unpack capture config
-        ##################################################
-        sample_rate      = parameters.get_parameter_value(PNames.SAMPLE_RATE)
-        bandwidth        = parameters.get_parameter_value(PNames.BANDWIDTH)
-        min_frequency    = parameters.get_parameter_value(PNames.MIN_FREQUENCY)
-        max_frequency    = parameters.get_parameter_value(PNames.MAX_FREQUENCY)
-        frequency_step   = parameters.get_parameter_value(PNames.FREQUENCY_STEP)
-        samples_per_step = parameters.get_parameter_value(PNames.SAMPLES_PER_STEP)
-        if_gain          = parameters.get_parameter_value(PNames.IF_GAIN)
-        rf_gain          = parameters.get_parameter_value(PNames.RF_GAIN)
-        batch_size       = parameters.get_parameter_value(PNames.BATCH_SIZE)
 
-
-        ##################################################
         # Blocks
-        ##################################################
         self.spectre_sweep_driver_0 = spectre.sweep_driver(min_frequency, 
                                                            max_frequency, 
                                                            frequency_step, 
@@ -143,16 +136,13 @@ class _swept_center_frequency(gr.top_block):
         self.sdrplay3_rsp1a_0.set_sample_sequence_gaps_check(False)
         self.sdrplay3_rsp1a_0.set_show_gain_changes(False)
 
-
-        ##################################################
         # Connections
-        ##################################################
         self.msg_connect((self.spectre_sweep_driver_0, 'freq'), (self.sdrplay3_rsp1a_0, 'freq'))
         self.connect((self.sdrplay3_rsp1a_0, 0), (self.spectre_batched_file_sink_0, 0))
         self.connect((self.sdrplay3_rsp1a_0, 0), (self.spectre_sweep_driver_0, 0))
 
 
 @dataclass(frozen=True)
-class CaptureMethods:
+class CaptureMethod:
     fixed_center_frequency  = partial(capture, top_block_cls=_fixed_center_frequency)
-    swept_center_frequency  = partial(capture, top_block_cls=_swept_center_frequency)
+    swept_center_frequency  = partial(capture, top_block_cls=_swept_center_frequency, max_noutput_items=1024)