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

spectre_core/receivers/gr/_rspduo.py

@@ -0,0 +1,227 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+#
+# SPDX-License-Identifier: GPL-3.0
+#
+# GNU Radio Python Flow Graph
+# Title: Test receiver
+# GNU Radio version: 3.10.1.1
+
+# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+#
+# RSPduo receiver top blocks
+#
+
+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.config import get_batches_dir_path
+from ._base import capture
+
+
+class _tuner_1_fixed_center_frequency(gr.top_block):
+    def __init__(self, 
+                 tag: str,
+                 parameters: Parameters):
+        gr.top_block.__init__(self, catch_exceptions=True)
+        gr.top_block.__init__(self, "tuner_1_fixed", 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)
+
+        ##################################################
+        # Blocks
+        ##################################################
+        self.spectre_batched_file_sink_0 = spectre.batched_file_sink(get_batches_dir_path(), 
+                                                                     tag, 
+                                                                     batch_size, 
+                                                                     sample_rate)
+        self.sdrplay3_rspduo_0 = sdrplay3.rspduo(
+            '',
+            rspduo_mode="Single Tuner",
+            antenna="Tuner 1 50 ohm",
+            stream_args=sdrplay3.stream_args(
+                output_type='fc32',
+                channels_size=1
+            ),
+        )
+        self.sdrplay3_rspduo_0.set_sample_rate(sample_rate)
+        self.sdrplay3_rspduo_0.set_center_freq(center_freq)
+        self.sdrplay3_rspduo_0.set_bandwidth(bandwidth)
+        self.sdrplay3_rspduo_0.set_antenna("Tuner 1 50 ohm")
+        self.sdrplay3_rspduo_0.set_gain_mode(False)
+        self.sdrplay3_rspduo_0.set_gain(if_gain, 'IF')
+        self.sdrplay3_rspduo_0.set_gain(rf_gain, 'RF')
+        self.sdrplay3_rspduo_0.set_freq_corr(0)
+        self.sdrplay3_rspduo_0.set_dc_offset_mode(False)
+        self.sdrplay3_rspduo_0.set_iq_balance_mode(False)
+        self.sdrplay3_rspduo_0.set_agc_setpoint(-30)
+        self.sdrplay3_rspduo_0.set_rf_notch_filter(False)
+        self.sdrplay3_rspduo_0.set_dab_notch_filter(False)
+        self.sdrplay3_rspduo_0.set_am_notch_filter(False)
+        self.sdrplay3_rspduo_0.set_biasT(False)
+        self.sdrplay3_rspduo_0.set_debug_mode(False)
+        self.sdrplay3_rspduo_0.set_sample_sequence_gaps_check(False)
+        self.sdrplay3_rspduo_0.set_show_gain_changes(False)
+
+
+        ##################################################
+        # Connections
+        ##################################################
+        self.connect((self.sdrplay3_rspduo_0, 0), (self.spectre_batched_file_sink_0, 0))
+    
+        
+class _tuner_2_fixed_center_frequency(gr.top_block):
+    def __init__(self, 
+                 tag: str,
+                 parameters: Parameters):
+        gr.top_block.__init__(self, catch_exceptions=True)
+        gr.top_block.__init__(self, "tuner_1_fixed", 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)
+
+        ##################################################
+        # Blocks
+        ##################################################
+        self.spectre_batched_file_sink_0 = spectre.batched_file_sink(get_batches_dir_path(), 
+                                                                     tag, 
+                                                                     batch_size, 
+                                                                     sample_rate)
+        self.sdrplay3_rspduo_0 = sdrplay3.rspduo(
+            '',
+            rspduo_mode="Single Tuner",
+            antenna="Tuner 2 50 ohm",
+            stream_args=sdrplay3.stream_args(
+                output_type='fc32',
+                channels_size=1
+            ),
+        )
+        self.sdrplay3_rspduo_0.set_sample_rate(sample_rate)
+        self.sdrplay3_rspduo_0.set_center_freq(center_freq)
+        self.sdrplay3_rspduo_0.set_bandwidth(bandwidth)
+        self.sdrplay3_rspduo_0.set_antenna("Tuner 2 50 ohm")
+        self.sdrplay3_rspduo_0.set_gain_mode(False)
+        self.sdrplay3_rspduo_0.set_gain(if_gain, 'IF')
+        self.sdrplay3_rspduo_0.set_gain(rf_gain, 'RF', False)
+        self.sdrplay3_rspduo_0.set_freq_corr(0)
+        self.sdrplay3_rspduo_0.set_dc_offset_mode(False)
+        self.sdrplay3_rspduo_0.set_iq_balance_mode(False)
+        self.sdrplay3_rspduo_0.set_agc_setpoint(-30)
+        self.sdrplay3_rspduo_0.set_rf_notch_filter(False)
+        self.sdrplay3_rspduo_0.set_dab_notch_filter(False)
+        self.sdrplay3_rspduo_0.set_am_notch_filter(False)
+        self.sdrplay3_rspduo_0.set_biasT(False)
+        self.sdrplay3_rspduo_0.set_stream_tags(False)
+        self.sdrplay3_rspduo_0.set_debug_mode(False)
+        self.sdrplay3_rspduo_0.set_sample_sequence_gaps_check(False)
+        self.sdrplay3_rspduo_0.set_show_gain_changes(False)
+
+
+        ##################################################
+        # Connections
+        ##################################################
+        self.connect((self.sdrplay3_rspduo_0, 0), (self.spectre_batched_file_sink_0, 0))    
+
+
+class _tuner_1_swept_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)
+        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, 
+                                                           sample_rate, 
+                                                           samples_per_step,
+                                                           'freq')
+        self.spectre_batched_file_sink_0 = spectre.batched_file_sink(get_batches_dir_path(), 
+                                                                     tag, 
+                                                                     batch_size, 
+                                                                     sample_rate, 
+                                                                     True, 
+                                                                     'freq', 
+                                                                     min_frequency)
+        self.sdrplay3_rspduo_0 = sdrplay3.rspduo(
+            '',
+            rspduo_mode="Single Tuner",
+            antenna="Tuner 1 50 ohm",
+            stream_args=sdrplay3.stream_args(
+                output_type='fc32',
+                channels_size=1
+            ),
+        )
+        self.sdrplay3_rspduo_0.set_sample_rate(sample_rate, True)
+        self.sdrplay3_rspduo_0.set_center_freq(min_frequency, True)
+        self.sdrplay3_rspduo_0.set_bandwidth(bandwidth)
+        self.sdrplay3_rspduo_0.set_antenna("Tuner 1 50 ohm")
+        self.sdrplay3_rspduo_0.set_gain_mode(False)
+        self.sdrplay3_rspduo_0.set_gain(if_gain, 'IF', True)
+        self.sdrplay3_rspduo_0.set_gain(rf_gain, 'RF', True)
+        self.sdrplay3_rspduo_0.set_freq_corr(0)
+        self.sdrplay3_rspduo_0.set_dc_offset_mode(False)
+        self.sdrplay3_rspduo_0.set_iq_balance_mode(False)
+        self.sdrplay3_rspduo_0.set_agc_setpoint(-30)
+        self.sdrplay3_rspduo_0.set_rf_notch_filter(False)
+        self.sdrplay3_rspduo_0.set_dab_notch_filter(True)
+        self.sdrplay3_rspduo_0.set_am_notch_filter(False)
+        self.sdrplay3_rspduo_0.set_biasT(False)
+        self.sdrplay3_rspduo_0.set_stream_tags(True)
+        self.sdrplay3_rspduo_0.set_debug_mode(False)
+        self.sdrplay3_rspduo_0.set_sample_sequence_gaps_check(False)
+        self.sdrplay3_rspduo_0.set_show_gain_changes(False)
+
+
+        ##################################################
+        # Connections
+        ##################################################
+        self.msg_connect((self.spectre_sweep_driver_0, 'freq'), (self.sdrplay3_rspduo_0, 'freq'))
+        self.connect((self.sdrplay3_rspduo_0, 0), (self.spectre_batched_file_sink_0, 0))
+        self.connect((self.sdrplay3_rspduo_0, 0), (self.spectre_sweep_driver_0, 0))
+        
+        
+@dataclass(frozen=True)
+class CaptureMethods:
+    tuner_1_fixed_center_frequency  = partial(capture, top_block_cls=_tuner_1_fixed_center_frequency)
+    tuner_2_fixed_center_frequency  = partial(capture, top_block_cls=_tuner_2_fixed_center_frequency)
+    tuner_1_swept_center_frequency  = partial(capture, top_block_cls=_tuner_1_swept_center_frequency)

spectre_core/receivers/gr/_test.py

@@ -25,7 +25,7 @@ from gnuradio import spectre
 from gnuradio import analog
 
 from spectre_core.capture_configs import Parameters, PNames
-from spectre_core.config import get_chunks_dir_path
+from spectre_core.config import get_batches_dir_path
 from ._base import capture
 
 
@@ -33,7 +33,7 @@ class _cosine_signal_1(gr.top_block):
     def __init__(self, 
                  tag: str,
                  parameters: Parameters):
-        gr.top_block.__init__(self, "cosine-signal-1", catch_exceptions=True)
+        gr.top_block.__init__(self, catch_exceptions=True)
 
         ##################################################
         # Unpack capture config
@@ -46,7 +46,7 @@ class _cosine_signal_1(gr.top_block):
         ##################################################
         # Blocks
         ##################################################
-        self.spectre_batched_file_sink_0 = spectre.batched_file_sink(get_chunks_dir_path(), 
+        self.spectre_batched_file_sink_0 = spectre.batched_file_sink(get_batches_dir_path(), 
                                                                      tag, 
                                                                      batch_size, 
                                                                      samp_rate)
@@ -80,7 +80,7 @@ class _tagged_staircase(gr.top_block):
     def __init__(self, 
                  tag: str,
                  parameters: Parameters):
-        gr.top_block.__init__(self, "tagged-staircase", catch_exceptions=True)
+        gr.top_block.__init__(self, catch_exceptions=True)
 
         ##################################################
         # Unpack capture config
@@ -100,7 +100,7 @@ class _tagged_staircase(gr.top_block):
                                                                    frequency_step,
                                                                    step_increment, 
                                                                    samp_rate)
-        self.spectre_batched_file_sink_0 = spectre.batched_file_sink(get_chunks_dir_path(),
+        self.spectre_batched_file_sink_0 = spectre.batched_file_sink(get_batches_dir_path(),
                                                                      tag, 
                                                                      batch_size, 
                                                                      samp_rate, 

spectre_core/receivers/library/_rsp1a.py

@@ -11,7 +11,7 @@ from spectre_core.capture_configs import (
 )
 from ..gr._rsp1a import CaptureMethods
 from .._spec_names import SpecNames
-from .._base import SDRPlayReceiver
+from ._sdrplay_receiver import SDRPlayReceiver
 from .._register import register_receiver
 
 @dataclass
@@ -44,7 +44,7 @@ class _Receiver(SDRPlayReceiver):
         self.add_capture_method(Modes.FIXED_CENTER_FREQUENCY, 
                                 CaptureMethods.fixed_center_frequency)
         self.add_capture_method(Modes.SWEPT_CENTER_FREQUENCY,
-                                CaptureMethods._swept_center_frequency)
+                                CaptureMethods.swept_center_frequency)
     
 
     def _add_capture_templates(self):
@@ -55,7 +55,7 @@ class _Receiver(SDRPlayReceiver):
         
     
     def _add_pvalidators(self):
-        self.add_pvalidator(CaptureModes.FIXED_CENTER_FREQUENCY,
+        self.add_pvalidator(Modes.FIXED_CENTER_FREQUENCY,
                             self._get_pvalidator_fixed_center_frequency())
-        self.add_pvalidator(CaptureModes.SWEPT_CENTER_FREQUENCY,
+        self.add_pvalidator(Modes.SWEPT_CENTER_FREQUENCY,
                             self._get_pvalidator_swept_center_frequency())

spectre_core/receivers/library/_rspduo.py

@@ -0,0 +1,69 @@
+# 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 dataclasses import dataclass
+from functools import partial
+
+from spectre_core.capture_configs import (
+    CaptureModes
+)
+from ..gr._rspduo import CaptureMethods
+from .._spec_names import SpecNames
+from ._sdrplay_receiver import SDRPlayReceiver
+from .._register import register_receiver
+
+@dataclass
+class Modes:
+    TUNER_1_FIXED_CENTER_FREQUENCY  = f"tuner-1-{CaptureModes.FIXED_CENTER_FREQUENCY}"
+    TUNER_2_FIXED_CENTER_FREQUENCY  = f"tuner-2-{CaptureModes.FIXED_CENTER_FREQUENCY}"
+    TUNER_1_SWEPT_CENTER_FREQUENCY  = f"tuner-1-{CaptureModes.SWEPT_CENTER_FREQUENCY}"
+
+
+@register_receiver("rspduo")
+class _Receiver(SDRPlayReceiver):
+    def __init__(self, 
+                 name: str,
+                 mode: Optional[str]):
+        super().__init__(name,
+                         mode)
+        
+
+    def _add_specs(self) -> None:
+        self.add_spec( SpecNames.SAMPLE_RATE_LOWER_BOUND, 200e3     ) # Hz
+        self.add_spec( SpecNames.SAMPLE_RATE_UPPER_BOUND, 10e6      ) # Hz
+        self.add_spec( SpecNames.FREQUENCY_LOWER_BOUND  , 1e3       ) # Hz
+        self.add_spec( SpecNames.FREQUENCY_UPPER_BOUND  , 2e9       ) # Hz
+        self.add_spec( SpecNames.IF_GAIN_UPPER_BOUND    , -20       ) # dB
+        self.add_spec( SpecNames.RF_GAIN_UPPER_BOUND    , 0         ) # dB
+        self.add_spec( SpecNames.API_RETUNING_LATENCY   , 50 * 1e-3 ) # s
+        self.add_spec( SpecNames.BANDWIDTH_OPTIONS, 
+                      [200000, 300000, 600000, 1536000, 5000000, 6000000, 7000000, 8000000])
+
+
+    def _add_capture_methods(self) -> None:
+        self.add_capture_method(Modes.TUNER_1_FIXED_CENTER_FREQUENCY, 
+                                CaptureMethods.tuner_1_fixed_center_frequency)
+        self.add_capture_method(Modes.TUNER_2_FIXED_CENTER_FREQUENCY, 
+                                CaptureMethods.tuner_2_fixed_center_frequency)
+        self.add_capture_method(Modes.TUNER_1_SWEPT_CENTER_FREQUENCY, 
+                                CaptureMethods.tuner_1_swept_center_frequency)
+    
+
+    def _add_capture_templates(self):
+        self.add_capture_template(Modes.TUNER_1_FIXED_CENTER_FREQUENCY,
+                                  self._get_capture_template_fixed_center_frequency())
+        self.add_capture_template(Modes.TUNER_2_FIXED_CENTER_FREQUENCY,
+                                  self._get_capture_template_fixed_center_frequency())
+        self.add_capture_template(Modes.TUNER_1_SWEPT_CENTER_FREQUENCY,
+                                  self._get_capture_template_swept_center_frequency())
+        
+    
+    def _add_pvalidators(self):
+        self.add_pvalidator(Modes.TUNER_1_FIXED_CENTER_FREQUENCY,
+                            self._get_pvalidator_fixed_center_frequency())
+        self.add_pvalidator(Modes.TUNER_2_FIXED_CENTER_FREQUENCY,
+                            self._get_pvalidator_fixed_center_frequency())
+        self.add_pvalidator(Modes.TUNER_1_SWEPT_CENTER_FREQUENCY,
+                            self._get_pvalidator_swept_center_frequency())

spectre_core/receivers/library/_sdrplay_receiver.py

@@ -0,0 +1,185 @@
+# 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 Callable, Optional
+from numbers import Number
+
+from spectre_core.capture_configs import (
+    CaptureTemplate, CaptureModes, Parameters, Bound, PValidators, PNames,
+    get_base_capture_template, get_base_ptemplate, OneOf, CaptureConfig
+)
+from .._base import BaseReceiver
+from .._spec_names import SpecNames
+
+class SDRPlayReceiver(BaseReceiver):
+    def _get_pvalidator_fixed_center_frequency(self) -> Callable:
+        def pvalidator(parameters: Parameters):
+            PValidators.fixed_center_frequency(parameters)
+        return pvalidator
+
+
+    def _get_pvalidator_swept_center_frequency(self) -> None:
+        def pvalidator(parameters: Parameters):
+            PValidators.swept_center_frequency(parameters,
+                                               self.get_spec(SpecNames.API_RETUNING_LATENCY))
+        return pvalidator
+
+
+    def _get_capture_template_fixed_center_frequency(self) -> CaptureTemplate:
+        #
+        # Create the base template
+        #
+        capture_template = get_base_capture_template( CaptureModes.FIXED_CENTER_FREQUENCY )
+        capture_template.add_ptemplate( get_base_ptemplate(PNames.BANDWIDTH) )
+        capture_template.add_ptemplate( get_base_ptemplate(PNames.IF_GAIN) )
+        capture_template.add_ptemplate( get_base_ptemplate(PNames.RF_GAIN) )
+
+        #
+        # Update the defaults
+        #
+        capture_template.set_defaults(
+            (PNames.BATCH_SIZE,            3.0),
+            (PNames.CENTER_FREQUENCY,      95800000),
+            (PNames.SAMPLE_RATE,           600000),
+            (PNames.BANDWIDTH,             600000),
+            (PNames.WINDOW_HOP,            512),
+            (PNames.WINDOW_SIZE,           1024),
+            (PNames.WINDOW_TYPE,           "blackman"),
+            (PNames.RF_GAIN,               -30),
+            (PNames.IF_GAIN,               -30)
+        )   
+
+        #
+        # Adding pconstraints
+        #
+        capture_template.add_pconstraint(
+            PNames.CENTER_FREQUENCY,
+            [
+                Bound(
+                    lower_bound=self.get_spec(SpecNames.FREQUENCY_LOWER_BOUND),
+                    upper_bound=self.get_spec(SpecNames.FREQUENCY_UPPER_BOUND)
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PNames.SAMPLE_RATE,
+            [
+                Bound(
+                    lower_bound=self.get_spec(SpecNames.SAMPLE_RATE_LOWER_BOUND),
+                    upper_bound=self.get_spec(SpecNames.SAMPLE_RATE_UPPER_BOUND)
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PNames.BANDWIDTH,
+            [
+                OneOf(
+                    self.get_spec( SpecNames.BANDWIDTH_OPTIONS )
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PNames.IF_GAIN,
+            [
+                Bound(
+                    upper_bound=self.get_spec(SpecNames.IF_GAIN_UPPER_BOUND)
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PNames.RF_GAIN,
+            [
+                Bound(
+                    upper_bound=self.get_spec(SpecNames.RF_GAIN_UPPER_BOUND)
+                )
+            ]
+        )
+        return capture_template
+
+
+    def _get_capture_template_swept_center_frequency(self) -> CaptureTemplate:
+        #
+        # Create the base template
+        #
+        capture_template = get_base_capture_template( CaptureModes.SWEPT_CENTER_FREQUENCY )
+        capture_template.add_ptemplate( get_base_ptemplate(PNames.BANDWIDTH) )
+        capture_template.add_ptemplate( get_base_ptemplate(PNames.IF_GAIN) )
+        capture_template.add_ptemplate( get_base_ptemplate(PNames.RF_GAIN) )
+
+
+        #
+        # Update the defaults
+        #
+        capture_template.set_defaults(
+            (PNames.BATCH_SIZE,            4.0),
+            (PNames.MIN_FREQUENCY,         95000000),
+            (PNames.MAX_FREQUENCY,         100000000),
+            (PNames.SAMPLES_PER_STEP,      80000),
+            (PNames.FREQUENCY_STEP,        1536000),
+            (PNames.SAMPLE_RATE,           1536000),
+            (PNames.BANDWIDTH,             1536000),
+            (PNames.WINDOW_HOP,            512),
+            (PNames.WINDOW_SIZE,           1024),
+            (PNames.WINDOW_TYPE,           "blackman"),
+            (PNames.RF_GAIN,               -30),
+            (PNames.IF_GAIN,               -30)
+        )   
+
+
+        #
+        # Adding pconstraints
+        #
+        capture_template.add_pconstraint(
+            PNames.MIN_FREQUENCY,
+            [
+                Bound(
+                    lower_bound=self.get_spec(SpecNames.FREQUENCY_LOWER_BOUND),
+                    upper_bound=self.get_spec(SpecNames.FREQUENCY_UPPER_BOUND)
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PNames.MAX_FREQUENCY,
+            [
+                Bound(
+                    lower_bound=self.get_spec(SpecNames.FREQUENCY_LOWER_BOUND),
+                    upper_bound=self.get_spec(SpecNames.FREQUENCY_UPPER_BOUND)
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PNames.SAMPLE_RATE,
+            [
+                Bound(
+                    lower_bound=self.get_spec(SpecNames.SAMPLE_RATE_LOWER_BOUND),
+                    upper_bound=self.get_spec(SpecNames.SAMPLE_RATE_UPPER_BOUND)
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PNames.BANDWIDTH,
+            [
+                OneOf(
+                    self.get_spec( SpecNames.BANDWIDTH_OPTIONS )
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PNames.IF_GAIN,
+            [
+                Bound(
+                    upper_bound=self.get_spec(SpecNames.IF_GAIN_UPPER_BOUND)
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PNames.RF_GAIN,
+            [
+                Bound(
+                    upper_bound=self.get_spec(SpecNames.RF_GAIN_UPPER_BOUND)
+                )
+            ]
+        )
+        return capture_template

spectre_core/receivers/library/_test.py

@@ -123,7 +123,7 @@ class _Receiver(BaseReceiver):
                 PNames.WINDOW_HOP,
                 PNames.WINDOW_SIZE,
                 PNames.EVENT_HANDLER_KEY,
-                PNames.CHUNK_KEY,
+                PNames.BATCH_KEY,
                 PNames.WATCH_EXTENSION,
                 PNames.MIN_SAMPLES_PER_STEP,
                 PNames.MAX_SAMPLES_PER_STEP,
@@ -152,7 +152,7 @@ class _Receiver(BaseReceiver):
             (PNames.WINDOW_SIZE,           512),
             (PNames.WINDOW_TYPE,           "boxcar"),
             (PNames.EVENT_HANDLER_KEY,     CaptureModes.SWEPT_CENTER_FREQUENCY),
-            (PNames.CHUNK_KEY,             CaptureModes.SWEPT_CENTER_FREQUENCY),
+            (PNames.BATCH_KEY,             CaptureModes.SWEPT_CENTER_FREQUENCY),
             (PNames.WATCH_EXTENSION,       "bin")
         )
 
@@ -166,7 +166,7 @@ class _Receiver(BaseReceiver):
             PNames.FREQUENCY_RESOLUTION,
             PNames.WINDOW_TYPE,
             PNames.EVENT_HANDLER_KEY,
-            PNames.CHUNK_KEY,
+            PNames.BATCH_KEY,
             PNames.WATCH_EXTENSION
         )
 

spectre_core/spectrograms/_analytical.py

@@ -12,12 +12,6 @@ from spectre_core.exceptions import ModeNotFoundError
 from ._spectrogram import Spectrogram
 from ._array_operations import is_close
 
-__all__ = [
-    "get_analytical_spectrogram",
-    "validate_analytically",
-    "TestResults"
-]
-
 @dataclass
 class TestResults:
     # Whether the times array matches analytically