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

spectre_core/receivers/library/rspduo/receiver.py

@@ -1,97 +0,0 @@
-# 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.receivers.base import SDRPlayReceiver
-from spectre_core.receivers.receiver_register import register_receiver
-from spectre_core.receivers.library.rspduo.gr import (
-    tuner_1_fixed, 
-    tuner_1_sweep,
-    tuner_2_fixed,
-    tuner_2_sweep
-)
-from spectre_core.file_handlers.configs import CaptureConfig
-
-
-@register_receiver("rspduo")
-class Receiver(SDRPlayReceiver):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-
-    def _set_capture_methods(self) -> None:
-        self._capture_methods = {
-            "tuner-1-fixed": self.__tuner_1_fixed,
-            "tuner-1-sweep": self.__tuner_1_sweep,
-            "tuner-2-fixed": self.__tuner_2_fixed,
-            "tuner-2-sweep": self.__tuner_2_sweep
-        }
-    
-
-    def _set_validators(self) -> None:
-        self._validators = {
-            "tuner-1-fixed": self.__tuner_1_fixed_validator,
-            "tuner-1-sweep": self.__tuner_1_sweep_validator,
-            "tuner-2-fixed": self.__tuner_2_fixed_validator,
-            "tuner-2-sweep": self.__tuner_2_sweep_validator,
-        }
-        return
-    
-
-    def _set_type_templates(self) -> None:
-        self._type_templates = {
-            "tuner-1-fixed": self._get_default_type_template("fixed"),
-            "tuner-1-sweep": self._get_default_type_template("sweep"),
-            "tuner-2-fixed": self._get_default_type_template("fixed"),
-            "tuner-2-sweep": self._get_default_type_template("sweep"),
-        }
-
-    def _set_specifications(self) -> None:
-        self._specifications = {
-            "center_freq_lower_bound": 1e3, # [Hz]
-            "center_freq_upper_bound": 2e9, # [Hz]
-            "samp_rate_lower_bound": 200e3, # [Hz]
-            "samp_rate_upper_bound": 10e6, # [Hz]
-            "bandwidth_lower_bound": 200e3, # [Hz]
-            "bandwidth_upper_bound": 8e6, # [Hz]
-            "IF_gain_upper_bound": -20, # [dB]
-            "RF_gain_upper_bound": 0, # [dB]
-            "api_latency": 50 * 1e-3 # [s]
-        }
-
-
-    def __tuner_1_fixed(self, capture_config: CaptureConfig) -> None:
-        tuner_1_fixed.main(capture_config)
-    
-
-    def __tuner_1_sweep(self, capture_config: CaptureConfig) -> None:
-        tuner_1_sweep.main(capture_config)
-
-    
-    def __tuner_2_fixed(self, capture_config: CaptureConfig) -> None:
-        tuner_2_fixed.main(capture_config)
-    
-
-    def __tuner_2_sweep(self, capture_config: CaptureConfig) -> None:
-        tuner_2_sweep.main(capture_config)
-
-
-    def __tuner_1_fixed_validator(self, capture_config: CaptureConfig) -> None:
-        self._default_fixed_validator(capture_config)
-        self._sdrplay_validator(capture_config)
- 
-
-    def __tuner_1_sweep_validator(self, capture_config: CaptureConfig) -> None:
-        self._default_sweep_validator(capture_config)
-        self._sdrplay_validator(capture_config)  
-
-
-    def __tuner_2_fixed_validator(self, capture_config: CaptureConfig) -> None:
-        self._default_fixed_validator(capture_config)
-        self._sdrplay_validator(capture_config)
-
-
-    def __tuner_2_sweep_validator(self, capture_config: CaptureConfig) -> None:
-        self._default_sweep_validator(capture_config)
-        self._sdrplay_validator(capture_config)
-    

spectre_core/receivers/library/test/gr/cosine_signal_1.py

@@ -1,83 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-#
-# SPDX-License-Identifier: GPL-3.0
-#
-# GNU Radio Python Flow Graph
-# Title: Not titled yet
-# 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
-
-import sys
-import signal
-from typing import Any
-
-from gnuradio import analog
-from gnuradio import blocks
-from gnuradio import gr
-from gnuradio.filter import firdes
-from gnuradio.fft import window
-from gnuradio.eng_arg import eng_float, intx
-from gnuradio import eng_notation
-from gnuradio import spectre
-
-from spectre_core.cfg import CHUNKS_DIR_PATH
-from spectre_core.file_handlers.configs import CaptureConfig
-
-class cosine_signal_1(gr.top_block):
-
-    def __init__(self, 
-                 capture_config: CaptureConfig):
-        gr.top_block.__init__(self, "cosine-signal-1", catch_exceptions=True)
-
-        ##################################################
-        # Unpack capture config
-        ##################################################
-        samp_rate = capture_config['samp_rate']
-        tag = capture_config['tag']
-        chunk_size = capture_config['chunk_size']
-        frequency = capture_config['frequency']
-        amplitude = capture_config['amplitude']
-
-        ##################################################
-        # Blocks
-        ##################################################
-        self.spectre_batched_file_sink_0 = spectre.batched_file_sink(CHUNKS_DIR_PATH, tag, chunk_size, samp_rate)
-        self.blocks_throttle_0_1 = blocks.throttle(gr.sizeof_float*1, samp_rate,True)
-        self.blocks_throttle_0 = blocks.throttle(gr.sizeof_float*1, samp_rate,True)
-        self.blocks_null_source_1 = blocks.null_source(gr.sizeof_float*1)
-        self.blocks_float_to_complex_1 = blocks.float_to_complex(1)
-        self.analog_sig_source_x_0 = analog.sig_source_f(samp_rate, analog.GR_COS_WAVE, frequency, amplitude, 0, 0)
-
-
-        ##################################################
-        # Connections
-        ##################################################
-        self.connect((self.analog_sig_source_x_0, 0), (self.blocks_throttle_0, 0))
-        self.connect((self.blocks_float_to_complex_1, 0), (self.spectre_batched_file_sink_0, 0))
-        self.connect((self.blocks_null_source_1, 0), (self.blocks_throttle_0_1, 0))
-        self.connect((self.blocks_throttle_0, 0), (self.blocks_float_to_complex_1, 0))
-        self.connect((self.blocks_throttle_0_1, 0), (self.blocks_float_to_complex_1, 1))
-
-
-def main(capture_config: CaptureConfig, 
-         top_block_cls=cosine_signal_1, 
-         options=None):
-    tb = top_block_cls(capture_config)
-
-    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.start()
-
-    tb.wait()

spectre_core/receivers/library/test/gr/tagged_staircase.py

@@ -1,93 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-#
-# SPDX-License-Identifier: GPL-3.0
-#
-# GNU Radio Python Flow Graph
-# Title: Not titled yet
-# 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
-
-import sys
-import signal
-from argparse import ArgumentParser
-from typing import Any
-
-from gnuradio import blocks
-from gnuradio import gr
-from gnuradio.filter import firdes
-from gnuradio.fft import window
-from gnuradio.eng_arg import eng_float, intx
-from gnuradio import eng_notation
-from gnuradio import spectre
-
-from spectre_core.cfg import CHUNKS_DIR_PATH
-from spectre_core.file_handlers.configs import CaptureConfig
-
-class tagged_staircase(gr.top_block):
-
-    def __init__(self, 
-                 capture_config: CaptureConfig):
-        gr.top_block.__init__(self, "tagged-staircase", catch_exceptions=True)
-
-        ##################################################
-        # Unpack capture config
-        ##################################################
-        tag = capture_config['tag']
-        step_increment = capture_config['step_increment']
-        samp_rate = capture_config['samp_rate']
-        min_samples_per_step = capture_config['min_samples_per_step']
-        max_samples_per_step = capture_config['max_samples_per_step']
-        freq_step = capture_config['freq_step']
-        chunk_size = capture_config['chunk_size']
-        is_sweeping = True
-
-        ##################################################
-        # Blocks
-        ##################################################
-        self.spectre_tagged_staircase_0 = spectre.tagged_staircase(min_samples_per_step, 
-                                                                   max_samples_per_step, 
-                                                                   freq_step,
-                                                                   step_increment, 
-                                                                   samp_rate)
-        self.spectre_batched_file_sink_0 = spectre.batched_file_sink(CHUNKS_DIR_PATH,
-                                                                     tag, 
-                                                                     chunk_size, 
-                                                                     samp_rate, 
-                                                                     is_sweeping,
-                                                                     'rx_freq',
-                                                                     0
-                                                                     )
-        self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex*1, samp_rate, True)
-
-
-        ##################################################
-        # Connections
-        ##################################################
-        self.connect((self.blocks_throttle_0, 0), (self.spectre_batched_file_sink_0, 0))
-        self.connect((self.spectre_tagged_staircase_0, 0), (self.blocks_throttle_0, 0))
-
-
-
-
-def main(capture_config: CaptureConfig, 
-         top_block_cls=tagged_staircase, 
-         options=None):
-    tb = top_block_cls(capture_config)
-
-    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.start()
-
-    tb.wait()

spectre_core/receivers/library/test/receiver.py

@@ -1,178 +0,0 @@
-# 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.receivers import validators
-from spectre_core.receivers.base import SPECTREReceiver
-from spectre_core.receivers.receiver_register import register_receiver
-from spectre_core.receivers.library.test.gr import cosine_signal_1
-from spectre_core.receivers.library.test.gr import tagged_staircase
-from spectre_core.file_handlers.configs import CaptureConfig
-
-
-@register_receiver("test")
-class Receiver(SPECTREReceiver):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-
-    def _set_capture_methods(self) -> None:
-        self._capture_methods = {
-            "cosine-signal-1": self.__cosine_signal_1,
-            "tagged-staircase": self.__tagged_staircase
-        }
-    
-
-    def _set_validators(self) -> None:
-        self._validators = {
-            "cosine-signal-1": self.__cosine_signal_1_validator,
-            "tagged-staircase": self.__tagged_staircase_validator
-        }
-    
-
-    def _set_type_templates(self) -> None:
-        self._type_templates = {
-            "cosine-signal-1": {
-                "samp_rate": int, # [Hz]
-                "frequency": float, # [Hz]
-                "amplitude": float, # unitless
-                "chunk_size": int, # [s]
-                "joining_time": int, # [s]
-                "time_resolution": float, # [s]
-                "frequency_resolution": float, # [Hz]
-                "window_type": str, # the window type for the STFFT
-                "window_kwargs": dict, # keyword arguments for scipy get window function. Must be in order as in scipy documentation.
-                "window_size": int, # number of samples for the window
-                "hop": int, # STFFT hop shifts window by so many samples
-                "chunk_key": str, # maps to the corresponding chunk class
-                "event_handler_key": str, # maps to the event handler used in post processing
-            },
-            "tagged-staircase": {
-                "samp_rate": int, # [Hz]
-                "min_samples_per_step": int, # [samples]
-                "max_samples_per_step": int, # [samples]
-                "freq_step": float, # [Hz]
-                "step_increment": int, # [samples]
-                "chunk_size": int, # [s]
-                "joining_time": int, # [s]
-                "time_resolution": float, # [s]
-                "frequency_resolution": float, # [Hz]
-                "window_type": str, # the window type for the STFFT
-                "window_kwargs": dict, # keyword arguments for scipy get window function. Must be in order as in scipy documentation.
-                "window_size": int, # number of samples for the window
-                "hop": int, # keyword arguments for scipy STFFT class
-                "chunk_key": str, # maps to the corresponding chunk class
-                "event_handler_key": str, # maps to the event handler used in post processing
-            }
-        }
-    
-    def _set_specifications(self) -> None:
-        self._specifications = {
-            "samp_rate_lower_bound": 64000
-        } 
-
-
-    def __cosine_signal_1(self, capture_config: CaptureConfig) -> None:
-        cosine_signal_1.main(capture_config)
-    
-
-    def __tagged_staircase(self, capture_config: CaptureConfig) -> None:
-        tagged_staircase.main(capture_config)
-    
-
-    def __cosine_signal_1_validator(self, capture_config: CaptureConfig) -> None:
-        # unpack the capture config
-        samp_rate = capture_config["samp_rate"]
-        frequency = capture_config["frequency"]
-        amplitude = capture_config["amplitude"]
-        chunk_size = capture_config["chunk_size"]
-        window_type = capture_config["window_type"]
-        window_size = capture_config["window_size"]
-        hop = capture_config["hop"]
-        chunk_key = capture_config["chunk_key"]
-        event_handler_key = capture_config["event_handler_key"]
-        time_resolution = capture_config["time_resolution"]
-        frequency_resolution = capture_config["frequency_resolution"]
-
-        validators.samp_rate_strictly_positive(samp_rate)
-        validators.chunk_size_strictly_positive(chunk_size)
-        validators.time_resolution(time_resolution, chunk_size) 
-        validators.window(window_type, 
-                                          {}, 
-                                          window_size,
-                                          chunk_size,
-                                          samp_rate)
-        validators.hop(hop)
-        validators.chunk_key(chunk_key, "fixed")
-        validators.event_handler_key(event_handler_key, "fixed")
-
-        if samp_rate < self.specifications.get("samp_rate_lower_bound"):
-            raise ValueError(f"Sample rate must be greater than or equal to {self.specifications.get('samp_rate_lower_bound')}")
-
-        if time_resolution != 0:
-            raise ValueError(f"Time resolution must be zero. Received: {time_resolution}")
-        
-        if frequency_resolution != 0:
-            raise ValueError(f"Frequency resolution must be zero. Received {frequency_resolution}")
-        
-        # check that the sample rate is an integer multiple of the underlying signal frequency
-        if samp_rate % frequency != 0:
-            raise ValueError("The sampling rate must be some integer multiple of frequency")
-
-        a = samp_rate/frequency
-        if a < 2:
-            raise ValueError(f"The ratio of sampling rate over frequency must be a natural number greater than two.  Received: {a}")
-        
-        # ensuring the window type is rectangular
-        if window_type != "boxcar":
-            raise ValueError(f"The window type must be \"boxcar\". Received: {window_type}")
-        
-        # 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. Computed that p={p}")
-    
-    
-        if amplitude <= 0:
-            raise ValueError(f"The amplitude must be strictly positive. Received: {amplitude}")
-    
-
-    def __tagged_staircase_validator(self, capture_config: CaptureConfig) -> None:
-        samp_rate = capture_config["samp_rate"]
-        min_samples_per_step = capture_config["min_samples_per_step"]
-        max_samples_per_step = capture_config["max_samples_per_step"]
-        freq_step = capture_config["freq_step"]
-        step_increment = capture_config["step_increment"]
-        chunk_size = capture_config["chunk_size"]
-        window_type = capture_config["window_type"]
-        window_kwargs = capture_config["window_kwargs"]
-        window_size = capture_config["window_size"]
-        hop = capture_config["hop"]
-        chunk_key = capture_config["chunk_key"]
-        event_handler_key = capture_config["event_handler_key"]
-        time_resolution = capture_config["time_resolution"]
-
-        validators.samp_rate_strictly_positive(samp_rate)
-        validators.chunk_size_strictly_positive(chunk_size)
-        validators.time_resolution(time_resolution, chunk_size)
-        validators.window(window_type, window_kwargs, window_size, chunk_size, samp_rate)
-        validators.hop(hop)
-        validators.chunk_key(chunk_key, "sweep")
-        validators.event_handler_key(event_handler_key, "sweep")
-
-        if freq_step != samp_rate:
-            raise ValueError(f"The frequency step must be equal to the sampling rate")
-        
-        if min_samples_per_step <= 0:
-            raise ValueError(f"Minimum samples per step must be strictly positive. Received: {min_samples_per_step}")
-        
-        if max_samples_per_step <= 0:
-            raise ValueError(f"Maximum samples per step must be strictly positive. Received: {max_samples_per_step}")
-        
-        if step_increment <= 0:
-            raise ValueError(f"Step increment must be strictly positive. Received: {step_increment}")
-        
-        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. Received: {min_samples_per_step} > {max_samples_per_step}")

spectre_core/receivers/validators.py

@@ -1,193 +0,0 @@
-# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
-# This file is part of SPECTRE
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-from logging import getLogger
-_LOGGER = getLogger(__name__)
-
-from math import floor
-import warnings
-
-from scipy.signal import get_window
-
-
-def closed_upper_bound_RF_gain(RF_gain: float, 
-                               RF_gain_upper_bound: float) -> None:
-    if not (RF_gain <= RF_gain_upper_bound):
-        raise ValueError(f"RF gain must be strictly less than or equal to {RF_gain_upper_bound} [dB]. Got {RF_gain} [dB]")
-
-
-def closed_upper_bound_IF_gain(IF_gain: float, 
-                               IF_gain_upper_bound: float) -> None:
-    if not (IF_gain <= IF_gain_upper_bound):
-        raise ValueError(f"IF gain must be strictly less than or equal to {IF_gain_upper_bound} [dB]. Got {IF_gain} [dB]")
-
-
-def closed_confine_center_freq(center_freq: float, 
-                               center_freq_lower_bound: float, 
-                               center_freq_upper_bound: float) -> None:
-    if not (center_freq_lower_bound <= center_freq <= center_freq_upper_bound):
-        raise ValueError(f"Center frequency must be between {center_freq_lower_bound*1e-3} [kHz] and {center_freq_upper_bound*1e-9} [GHz]. Received {center_freq*1e-6} [MHz]")
-    
-
-def closed_confine_samp_rate(samp_rate: int, 
-                             samp_rate_lower_bound: int, 
-                             samp_rate_upper_bound: int) -> None:
-    if not (samp_rate_lower_bound <= samp_rate <= samp_rate_upper_bound):
-        raise ValueError(f"Sampling rate must be between {samp_rate_lower_bound*1e-6} [MHz] and {samp_rate_upper_bound*1e-6} [MHz]. Received {samp_rate*1e-6} [MHz]")
-    
-
-def closed_confine_bandwidth(bandwidth: float, 
-                             bandwidth_lower_bound: float, 
-                             bandwidth_upper_bound: float) -> None:
-    if not (bandwidth_lower_bound <= bandwidth <= bandwidth_upper_bound):
-        raise ValueError(f"Bandwidth must be between {bandwidth_lower_bound*1e-3} [kHz] and {bandwidth_upper_bound*1e-6} [MHz]. Received {bandwidth*1e-6} [MHz]")
-    
-    
-def is_power_of_two(n):
-    return (n != 0) and (n & (n-1) == 0)
-
-
-def window(window_type: str, 
-           window_kwargs: dict, 
-           window_size: int,
-           chunk_size: int,
-           samp_rate: float) -> None:
-    
-    if not is_power_of_two(window_size):
-        raise ValueError(f"Window size must be some power of two. Received: {window_size}")
-    
-
-    if window_size*(1/samp_rate) > chunk_size:
-        raise ValueError("Windowing interval must be strictly less than the chunk size")
-    
-    try:
-        window_params = (window_type, 
-                         *window_kwargs.values())
-        _ = get_window(window_params, window_size)
-    except Exception as e:
-        raise Exception(f"An error has occurred while validating the window. Received: {str(e)}")
-    
-
-def hop(hop: int):
-    if hop < 0:
-        raise ValueError(f"\"hop\" must be strictly positive. Received: {hop_value}")
-    
-    
-def center_freq_strictly_positive(center_freq: float):
-    if center_freq <= 0:
-        raise ValueError(f"Center frequency must be strictly positive. Received: {center_freq*1e-6} [MHz]")
-    
-
-def bandwidth_strictly_positive(bandwidth: float) -> None:
-    if bandwidth < 0:
-        raise ValueError(f"Bandwidth must be non-negative. Received: {bandwidth*1e-6} [MHz]")
-    
-
-def nyquist_criterion(samp_rate: int, 
-                      bandwidth: float) -> None:
-    if samp_rate < bandwidth:
-        raise ValueError("Sample rate must be greater than or equal to the bandwidth")
-    
-
-def samp_rate_strictly_positive(samp_rate: int) -> None:
-    if samp_rate < 0:
-        raise ValueError(f"Sample rate must be strictly positive. Received: {samp_rate} [Hz]")
-    
-
-def chunk_size_strictly_positive(chunk_size: int) -> None:
-    if chunk_size <= 0:
-        raise ValueError(f"Chunk size must be strictly positive. Received: {chunk_size} [s]")
-    
-
-def time_resolution(time_resolution: float, 
-                    chunk_size: int) -> None:
-    if time_resolution < 0:
-        raise ValueError(f"Time resolution must be non-negative. Received: {time_resolution} [s]")
-    
-    if time_resolution > chunk_size:
-        raise ValueError("Time resolution must be less than or equal to chunk size")
-    
-
-def frequency_resolution(frequency_resolution: float,
-                         bandwidth: float = None) -> None:
-    if frequency_resolution < 0:
-        raise ValueError(f"Frequency resolution must be non-negative. Received {frequency_resolution} [Hz]")
-    
-    if bandwidth is not None and frequency_resolution >= bandwidth:
-        raise ValueError(f"Frequency resolution must be less than the bandwidth. Received frequency resolution to be {frequency_resolution} [Hz], with bandwidth {bandwidth} [Hz]")
-    
-
-def chunk_key(chunk_key: str, 
-              expected_chunk_key: str) -> None:
-    if chunk_key != expected_chunk_key:
-        raise ValueError(f"Expected \"{expected_chunk_key}\" for the chunk_key, received: {chunk_key}")
-    
-
-def event_handler_key(event_handler_key: str, 
-                      expected_event_handler_key: str) -> None:
-    if event_handler_key != expected_event_handler_key:
-        raise ValueError(f"Expected \"{expected_event_handler_key}\" for the event_handler_key, received: {event_handler_key}")
-    
-
-def gain_is_negative(gain: float) -> None:
-    if gain > 0:
-        raise ValueError(f"Gain must be non-positive. Received {gain} [dB]")
-    
-
-def _compute_num_steps_per_sweep(min_freq: float, 
-                                 max_freq: float,
-                                 samp_rate: int,
-                                 freq_step: float) -> int:
-     return floor((max_freq - min_freq + samp_rate/2) / freq_step)
-
-
-def num_steps_per_sweep(min_freq: float, 
-                        max_freq: float, 
-                        samp_rate: int, 
-                        freq_step: float) -> None:
-    num_steps_per_sweep = _compute_num_steps_per_sweep(min_freq, 
-                                                       max_freq, 
-                                                       samp_rate, 
-                                                       freq_step)
-    if num_steps_per_sweep <= 1:
-        raise ValueError(f"We need strictly greater than one sample per step. Computed: {num_steps_per_sweep}")
-    
-
-def sweep_interval(min_freq: float, 
-                  max_freq: float, 
-                  samp_rate: int, 
-                  freq_step: float,
-                  samples_per_step: int,
-                  chunk_size: float) -> None: 
-    num_steps_per_sweep = _compute_num_steps_per_sweep(min_freq, 
-                                                       max_freq, 
-                                                       samp_rate, 
-                                                       freq_step)
-    num_samples_per_sweep = num_steps_per_sweep * samples_per_step
-    sweep_interval = num_samples_per_sweep * 1/samp_rate
-    if sweep_interval > chunk_size:
-        raise ValueError(f"Sweep interval must be less than the chunk size. Computed sweep interval: {sweep_interval} [s] is greater than the given chunk size {chunk_size} [s]")
-    
-
-def num_samples_per_step(samples_per_step: int, 
-                         window_size: int) -> None:
-    if window_size >= samples_per_step:
-        raise ValueError(f"Window size must be strictly less than the number of samples per step. Received window size {window_size} [samples], which is more than or equal to the number of samples per step {samples_per_step}")
-    
-
-def non_overlapping_steps(freq_step: float, 
-                          samp_rate: int) -> None:
-    if freq_step < samp_rate:
-        raise NotImplementedError(f"SPECTRE does not yet support spectral steps overlapping in frequency. Received frequency step {freq_step/1e6} [MHz] which is less than the sample rate {samp_rate/1e6} [MHz]")
-    
-
-def step_interval(samples_per_step: int, 
-                  samp_rate: int, 
-                  api_latency: float) -> None:
-    step_interval = samples_per_step * 1/samp_rate # [s]
-    if step_interval < api_latency:
-        warning_message = f"The computed step interval of {step_interval} [s] is of the order of empirically derived api latency {api_latency} [s]; you may experience undefined behaviour!"
-        warnings.warn(warning_message)
-        _LOGGER.warning(warning_message)
-    

spectre_core/watchdog/__init__.py

@@ -1,6 +0,0 @@
-# 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 event handlers
-import spectre_core.watchdog.library