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

spectre_core/batches/library/_fixed_center_frequency.py

@@ -1,133 +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 datetime import datetime, timedelta
-from typing import Tuple
-import numpy as np
-
-from astropy.io import fits
-from astropy.io.fits.hdu.image import PrimaryHDU
-from astropy.io.fits.hdu.table import BinTableHDU
-from astropy.io.fits.hdu.hdulist import HDUList
-
-from spectre_core.config import TimeFormats
-from spectre_core.spectrograms import Spectrogram
-from spectre_core.capture_configs import CaptureModes
-from .._register import register_batch
-from .._base import BaseBatch, BatchFile
-
-
-@register_batch(CaptureModes.FIXED_CENTER_FREQUENCY)
-class _Batch(BaseBatch):
-    def __init__(self,
-                 start_time: str,
-                 tag: str):
-        super().__init__(start_time, tag) 
-        self.add_file( BinFile(self.parent_dir_path, self.name) )
-        self.add_file( HdrFile(self.parent_dir_path, self.name) )
-        self.add_file( FitsFile(self.parent_dir_path, self.name))
-
-
-class BinFile(BatchFile):
-    def __init__(self, 
-                 parent_dir_path: str, 
-                 base_file_name: str):
-        super().__init__(parent_dir_path, base_file_name, "bin")
-
-    def read(self) -> np.ndarray:
-        with open(self.file_path, "rb") as fh:
-            return np.fromfile(fh, dtype=np.complex64)
-
-
-  
-class HdrFile(BatchFile):
-    def __init__(self, 
-                 parent_dir_path: str, 
-                 base_file_name: str):
-        super().__init__(parent_dir_path, base_file_name, "hdr")
-
-
-    def read(self) -> int:
-        hdr_contents = self._extract_contents()
-        return self._get_millisecond_correction(hdr_contents)
-
-
-    def _extract_contents(self) -> np.ndarray:
-        with open(self.file_path, "rb") as fh:
-            return np.fromfile(fh, dtype=np.float32)
-
-
-    def _get_millisecond_correction(self, hdr_contents: np.ndarray) -> int:
-        if len(hdr_contents) != 1:
-            raise ValueError(f"Expected exactly one integer in the header, but received header contents: {hdr_contents}")
-        
-        millisecond_correction_as_float = float(hdr_contents[0])
-
-        if not millisecond_correction_as_float.is_integer():
-            raise TypeError(f"Expected integer value for millisecond correction, but got {millisecond_correction_as_float}")
-        
-        return int(millisecond_correction_as_float)
-        
-
-class FitsFile(BatchFile):
-    def __init__(self, 
-                 parent_dir_path: str, 
-                 base_file_name: str):
-        super().__init__(parent_dir_path, base_file_name, "fits")
-
-
-    @property
-    def datetimes(self) -> np.ndarray:
-        with fits.open(self.file_path, mode='readonly') as hdulist:
-            bintable_data = hdulist[1].data
-            times = bintable_data['TIME'][0]
-            return [self.start_datetime + timedelta(seconds=t) for t in times]
-        
-
-    def read(self) -> Spectrogram:
-        with fits.open(self.file_path, mode='readonly') as hdulist:
-            primary_hdu                = self._get_primary_hdu(hdulist)
-            dynamic_spectra            = self._get_dynamic_spectra(primary_hdu)
-            spectrum_type              = self._get_spectrum_type(primary_hdu)
-            spectrogram_start_datetime = self._get_spectrogram_start_datetime(primary_hdu)
-            bintable_hdu               = self._get_bintable_hdu(hdulist)
-            times, frequencies         = self._get_time_and_frequency(bintable_hdu)
-
-        return Spectrogram(dynamic_spectra, 
-                           times, 
-                           frequencies, 
-                           self.tag,
-                           spectrogram_start_datetime,
-                           spectrum_type)
-
-
-    def _get_primary_hdu(self, hdulist: HDUList) -> PrimaryHDU:
-        return hdulist['PRIMARY']
-
-
-    def _get_dynamic_spectra(self, primary_hdu: PrimaryHDU) -> np.ndarray:
-        return primary_hdu.data
-
-
-    def _get_spectrum_type(self, primary_hdu: PrimaryHDU) -> str:
-        return primary_hdu.header['BUNIT']
-
-
-    def _get_spectrogram_start_datetime(self, primary_hdu: PrimaryHDU) -> datetime:
-        date_obs = primary_hdu.header['DATE-OBS']
-        time_obs = primary_hdu.header['TIME-OBS']
-        return datetime.strptime(f"{date_obs}T{time_obs}", TimeFormats.PRECISE_DATETIME)
-
-
-    def _get_bintable_hdu(self, hdulist: HDUList) -> BinTableHDU:
-        return hdulist[1]
-
-
-    def _get_time_and_frequency(self, bintable_hdu: BinTableHDU) -> Tuple[np.ndarray, np.ndarray]:
-        data = bintable_hdu.data
-        times = data['TIME'][0]
-        frequencies_MHz = data['FREQUENCY'][0]
-        frequencies = frequencies_MHz * 1e6 # convert to Hz
-        return times, frequencies
-

spectre_core/batches/library/_swept_center_frequency.py

@@ -1,105 +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 typing import Tuple
-from dataclasses import dataclass
-
-import numpy as np
-
-from spectre_core.exceptions import InvalidSweepMetadataError
-from spectre_core.capture_configs import CaptureModes
-from ._fixed_center_frequency import BinFile, FitsFile
-from .._register import register_batch
-from .._base import BaseBatch, BatchFile
-
-
-@dataclass
-class SweepMetadata:
-    """Wrapper for metadata required to assign center frequencies to each IQ sample in the batch.
-    
-    center_frequencies is an ordered list containing all the center frequencies that the IQ samples
-    were collected at. Typically, these will be ordered in "steps", where each step corresponds to
-    IQ samples collected at a constant center frequency:
-
-    (freq_0, freq_1, ..., freq_M, freq_0, freq_1, ..., freq_M, ...), freq_0 < freq_1 < ... < freq_M
-
-    The n'th element of the num_samples list, tells us how many samples were collected at the n'th
-    element of center_frequencies.
-
-    Number of samples: (num_samples_at_freq_0, num_samples_at_freq_1, ...)
-
-    Both these lists together allow us to map for each IQ sample, the center frequency it was collected at.
-    """
-    center_frequencies: np.ndarray
-    num_samples: np.ndarray
-
-
-@register_batch(CaptureModes.SWEPT_CENTER_FREQUENCY)
-class _Batch(BaseBatch):
-    def __init__(self,
-                 start_time: str,
-                 tag: str):
-        super().__init__(start_time, tag) 
-        self.add_file( HdrFile(self.parent_dir_path, self.name) )
-        # reuse the binary and fits batch from the fixed center frequency case.
-        self.add_file( BinFile(self.parent_dir_path, self.name) )
-        self.add_file( FitsFile(self.parent_dir_path, self.name))
-        
-    
-class HdrFile(BatchFile):
-    def __init__(self, 
-                 parent_dir_path: str, 
-                 base_file_name: str):
-        super().__init__(parent_dir_path, base_file_name, "hdr")
-
-    def read(self) -> Tuple[int, SweepMetadata]:
-        hdr_contents = self._read_file_contents()
-        millisecond_correction = self._get_millisecond_correction(hdr_contents)
-        center_frequencies = self._get_center_frequencies(hdr_contents)
-        num_samples = self._get_num_samples(hdr_contents)
-        self._validate_frequencies_and_samples(center_frequencies, 
-                                               num_samples)
-        return millisecond_correction, SweepMetadata(center_frequencies, num_samples)
-        
-
-    def _read_file_contents(self) -> np.ndarray:
-        with open(self.file_path, "rb") as fh:
-            return np.fromfile(fh, dtype=np.float32)
-
-
-    def _get_millisecond_correction(self, hdr_contents: np.ndarray) -> int:
-        ''' Millisecond correction is an integral quantity, but stored in the detached header as a 32-bit float.'''
-        millisecond_correction_as_float = float(hdr_contents[0])
-
-        if not millisecond_correction_as_float.is_integer():
-            raise TypeError(f"Expected integer value for millisecond correction, but got {millisecond_correction_as_float}")
-        
-        return int(millisecond_correction_as_float)
-
-
-    def _get_center_frequencies(self, hdr_contents: np.ndarray) -> np.ndarray:
-        ''' 
-        Detached header contents are stored in (center_freq_i, num_samples_at_center_freq_i) pairs
-        Return only a list of center frequencies, by skipping over file contents in twos.
-        '''
-        return hdr_contents[1::2]
-
-
-    def _get_num_samples(self, hdr_contents: np.ndarray) -> np.ndarray:
-        ''' 
-        Detached header contents are stored in (center_freq_i, num_samples_at_center_freq_i) pairs
-        Return only the number of samples at each center frequency, by skipping over file contents in twos.
-        Number of samples is an integral quantity, but stored in the detached header as a 32-bit float.
-        Types are checked before return.
-        '''
-        num_samples_as_float = hdr_contents[2::2]
-        if not all(num_samples_as_float == num_samples_as_float.astype(int)):
-            raise InvalidSweepMetadataError("Number of samples per frequency is expected to describe an integer")
-        return num_samples_as_float.astype(int)
-
-
-    def _validate_frequencies_and_samples(self, center_frequencies: np.ndarray, num_samples: np.ndarray) -> None:
-        """Validates that the center frequencies and the number of samples arrays have the same length."""
-        if len(center_frequencies) != len(num_samples):
-            raise InvalidSweepMetadataError("Center frequencies and number of samples arrays are not the same length")

spectre_core/logging/__init__.py

@@ -1,11 +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 ._decorators import log_call
-from ._configure import configure_root_logger
-from ._log_handlers import LogHandler, LogHandlers
-
-__all__ = [
-    "log_call", "configure_root_logger", "LogHandler", "LogHandlers"
-]

spectre_core/logging/_configure.py

@@ -1,35 +0,0 @@
-# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
-# This file is part of SPECTRE
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-import os
-import logging
-from datetime import datetime
-
-from spectre_core.config import TimeFormats
-from ._log_handlers import LogHandler
-
-def configure_root_logger(process_type: str, 
-                          level: int = logging.INFO
-) -> LogHandler:
-    system_datetime = datetime.now()
-    datetime_stamp = system_datetime.strftime(TimeFormats.DATETIME)
-    pid = os.getpid()
-    log_handler = LogHandler(datetime_stamp, pid, process_type)
-    log_handler.make_parent_dir_path()
-
-    # configure the root logger
-    logger = logging.getLogger()
-    logger.setLevel(level)
-    # Remove any existing handlers to avoid duplicate logs
-    for handler in logger.handlers:
-        logger.removeHandler(handler)
-    # Set up file handler with specific filename
-    file_handler = logging.FileHandler(log_handler.file_path)
-    file_handler.setLevel(level)
-    formatter = logging.Formatter("[%(asctime)s] [%(levelname)8s] --- %(message)s (%(name)s:%(lineno)s)")
-    file_handler.setFormatter(formatter)
-    # and add it to the root logger
-    logger.addHandler(file_handler)
-
-    return log_handler

spectre_core/logging/_decorators.py

@@ -1,19 +0,0 @@
-# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
-# This file is part of SPECTRE
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-import logging
-from typing import Callable
-from functools import wraps
-
-def log_call(func: Callable) -> Callable:
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        logger = logging.getLogger(func.__module__)
-        try:
-            logger.info(f"Calling the function: {func.__name__}")
-            return func(*args, **kwargs)
-        except Exception as e:
-            logger.error(f"Error in function: {func.__name__}", exc_info=True)
-            raise
-    return wrapper

spectre_core/logging/_log_handlers.py

@@ -1,176 +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__)
-
-import os
-import logging
-from dataclasses import dataclass
-from typing import Optional
-import warnings
-from collections import OrderedDict
-from datetime import datetime
-
-from spectre_core._file_io import TextHandler
-from spectre_core.config import get_logs_dir_path, TimeFormats
-
-PROCESS_TYPES = [
-    "user", 
-    "worker"
-]
-
-def _validate_process_type(process_type: str
-) -> None:
-    if process_type not in PROCESS_TYPES:
-        raise ValueError(f"Invalid process type: {process_type}. Expected one of {PROCESS_TYPES}")
-
-
-class LogHandler(TextHandler):
-    def __init__(self, 
-                 datetime_stamp: str, 
-                 pid: str, 
-                 process_type: str):
-        self._datetime_stamp = datetime_stamp
-        self._pid = pid
-        _validate_process_type(process_type)
-        self._process_type = process_type
-
-        dt = datetime.strptime(datetime_stamp, TimeFormats.DATETIME)
-        parent_path = get_logs_dir_path(dt.year, dt.month, dt.day)
-        base_file_name = f"{datetime_stamp}_{pid}_{process_type}"
-
-        super().__init__(parent_path, base_file_name, extension = "log")
-    
-
-    @property
-    def datetime_stamp(self) -> str:
-        return self._datetime_stamp
-    
-
-    @property
-    def pid(self) -> str:
-        return self._pid
-    
-
-    @property
-    def process_type(self) -> str:
-        return self._process_type
-
-
-class LogHandlers:
-    def __init__(self, 
-                 process_type: Optional[str] = None, 
-                 year: Optional[int] = None, 
-                 month: Optional[int] = None, 
-                 day: Optional[int] = None):
-        self._process_type = process_type
-        self._log_handler_map: dict[str, LogHandler] = OrderedDict()
-        self.set_date(year, month, day)
-
-
-    @property
-    def process_type(self) -> str:
-        return self._process_type
-    
-
-    @property
-    def year(self) -> Optional[int]:
-        return self._year
-
-
-    @property 
-    def month(self) -> Optional[int]:
-        return self._month
-    
-
-    @property
-    def day(self) -> Optional[int]:
-        return self._day
-
-
-    @property
-    def logs_dir_path(self) -> str:
-        return get_logs_dir_path(self.year, self.month, self.day)
-
-
-    @property 
-    def log_handler_map(self) -> dict[str, LogHandler]:
-        if not self._log_handler_map: # check for empty dictionary
-            self._update_log_handler_map()
-        return self._log_handler_map
-        
-
-    @property
-    def log_handler_list(self) -> list[LogHandler]:
-        return list(self.log_handler_map.values())
-
-
-    @property
-    def num_logs(self) -> int:
-        return len(self.log_handler_list) 
-
-
-    @property
-    def file_names(self) -> list[str]:
-        return list(self.log_handler_map.keys())
-
-
-    def set_date(self, 
-                 year: Optional[int],
-                 month: Optional[int],
-                 day: Optional[int]) -> None:
-        self._year = year
-        self._month = month
-        self._day = day
-        self._update_log_handler_map()
-
-
-    def _update_log_handler_map(self) -> None:
-        log_files = [f for (_, _, files) in os.walk(self.logs_dir_path) for f in files]
-
-        if not log_files:
-            warning_message = "No logs found, setting log map to an empty dictionary"
-            _LOGGER.warning(warning_message)
-            warnings.warn(warning_message)
-            return
-
-        for log_file in log_files:
-            file_name, _ = os.path.splitext(log_file)
-            log_start_time, pid, process_type = file_name.split("_")
-
-            if self.process_type and process_type != self.process_type:
-                continue
-
-            self._log_handler_map[file_name] = LogHandler(log_start_time, pid, process_type)
-
-        self._log_handler_map = OrderedDict(sorted(self._log_handler_map.items()))
-
-
-    def update(self) -> None:
-        """Public alias for setting log handler map"""
-        self._update_log_handler_map()
-
-
-    def __iter__(self):
-        yield from self.log_handler_list
-
-
-    def get_from_file_name(self, 
-                           file_name: str) -> LogHandler:
-        # auto strip the extension if present
-        file_name, _ = os.path.splitext(file_name)
-        try:
-            return self.log_handler_map[file_name]
-        except KeyError:
-            raise FileNotFoundError(f"Log handler for file name '{file_name}' not found in log map")
-
-
-    def get_from_pid(self, 
-                     pid: str) -> LogHandler:
-        for log_handler in self.log_handler_list:
-            if log_handler.pid == pid:
-                return log_handler
-        raise FileNotFoundError(f"Log handler for PID '{pid}' not found in log map")

spectre_core/post_processing/library/_fixed_center_frequency.py

@@ -1,114 +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__)
-
-import numpy as np
-from typing import Tuple
-from datetime import timedelta
-
-import os
-
-from spectre_core.capture_configs import CaptureConfig, PNames, CaptureModes
-from spectre_core.batches import BaseBatch
-from spectre_core.spectrograms import Spectrogram, time_average, frequency_average
-from .._base import BaseEventHandler, make_sft_instance
-from .._register import register_event_handler
-
-
-def _do_stfft(iq_data: np.array,
-              capture_config: CaptureConfig,
-) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
-    """For reference: https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.ShortTimeFFT.html"""
-
-    sft = make_sft_instance(capture_config)
-
-    # set p0=0, since by convention in the STFFT docs, p=0 corresponds to the slice centred at t=0
-    p0=0
-
-    # set p1 to the index of the first slice where the "midpoint" of the window is still inside the signal
-    num_samples = len(iq_data)
-    p1 = sft.upper_border_begin(num_samples)[1]
-    
-    # compute a ShortTimeFFT on the IQ samples
-    complex_spectra = sft.stft(iq_data, 
-                               p0 = p0, 
-                               p1 = p1) 
-    
-    # compute the magnitude of each spectral component
-    dynamic_spectra = np.abs(complex_spectra)
-
-
-    # assign a physical time to each spectrum
-    # p0 is defined to correspond with the first sample, at t=0 [s]
-    times = sft.t(num_samples, 
-                  p0 = p0, 
-                  p1 = p1)
-    # assign physical frequencies to each spectral component
-    frequencies = sft.f + capture_config.get_parameter_value(PNames.CENTER_FREQUENCY) 
-
-    return times, frequencies, dynamic_spectra
-
-
-def _build_spectrogram(batch: BaseBatch,
-                       capture_config: CaptureConfig) -> Spectrogram:
-    """Create a spectrogram by performing a Short Time FFT on the IQ samples for this batch."""
-
-    # read the data from the batch
-    millisecond_correction = batch.read_file("hdr")
-    iq_data = batch.read_file("bin")
-
-    times, frequencies, dynamic_spectra = _do_stfft(iq_data,
-                                                    capture_config)
-
-    # explicitly type cast data arrays to 32-bit floats
-    times = np.array(times, dtype = 'float32')
-    frequencies = np.array(frequencies, dtype = 'float32')
-    dynamic_spectra = np.array(dynamic_spectra, dtype = 'float32')
-
-    # compute the start datetime for the spectrogram by adding the millisecond component to the batch start time
-    spectrogram_start_datetime = batch.start_datetime + timedelta(milliseconds=millisecond_correction)
-    return Spectrogram(dynamic_spectra,
-                       times,
-                       frequencies,
-                       batch.tag,
-                       spectrogram_start_datetime,
-                       spectrum_type = "amplitude")
-
-
-@register_event_handler(CaptureModes.FIXED_CENTER_FREQUENCY)
-class _EventHandler(BaseEventHandler):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-    def process(self, 
-                absolute_file_path: str):
-        _LOGGER.info(f"Processing: {absolute_file_path}")
-        file_name = os.path.basename(absolute_file_path)
-        base_file_name, _ = os.path.splitext(file_name)
-        batch_start_time, tag = base_file_name.split('_')
-
-        # create an instance of the current batch being processed
-        batch = self._Batch(batch_start_time, tag)
-
-        _LOGGER.info("Creating spectrogram")
-        spectrogram = _build_spectrogram(batch,
-                                        self._capture_config)
-
-        spectrogram = time_average(spectrogram,
-                                   resolution = self._capture_config.get_parameter_value(PNames.TIME_RESOLUTION))
-
-        spectrogram = frequency_average(spectrogram,
-                                        resolution = self._capture_config.get_parameter_value(PNames.FREQUENCY_RESOLUTION))
-        
-        self._cache_spectrogram(spectrogram)
-
-        bin_file = batch.get_file('bin')
-        _LOGGER.info(f"Deleting {bin_file.file_path}")
-        bin_file.delete()
-
-        hdr_file = batch.get_file('hdr')
-        _LOGGER.info(f"Deleting {hdr_file.file_path}")
-        hdr_file.delete()

spectre_core/receivers/gr/_base.py

@@ -1,33 +0,0 @@
-# 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 gnuradio import gr
-from gnuradio import spectre
-
-from spectre_core.capture_configs import Parameters, PNames
-from spectre_core.config import get_batches_dir_path
-
-from spectre_core.capture_configs import Parameters
-
-
-def capture(tag: str,
-            parameters: Parameters, 
-            top_block_cls: gr.top_block,
-            max_noutput_items: int = 10000000):
-    tb: gr.top_block = 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.start(max_noutput_items)
-    tb.wait()

spectre_core/receivers/library/_rsp1a.py

@@ -1,61 +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 typing import Optional
-from dataclasses import dataclass
-from functools import partial
-
-from spectre_core.capture_configs import (
-    CaptureModes
-)
-from ..gr._rsp1a import CaptureMethods
-from .._spec_names import SpecNames
-from ._sdrplay_receiver import SDRPlayReceiver
-from .._register import register_receiver
-
-@dataclass
-class Modes:
-    FIXED_CENTER_FREQUENCY  = CaptureModes.FIXED_CENTER_FREQUENCY
-    SWEPT_CENTER_FREQUENCY  = CaptureModes.SWEPT_CENTER_FREQUENCY
-
-@register_receiver("rsp1a")
-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.FIXED_CENTER_FREQUENCY, 
-                                CaptureMethods.fixed_center_frequency)
-        self.add_capture_method(Modes.SWEPT_CENTER_FREQUENCY,
-                                CaptureMethods.swept_center_frequency)
-    
-
-    def _add_capture_templates(self):
-        self.add_capture_template(Modes.FIXED_CENTER_FREQUENCY,
-                                  self._get_capture_template_fixed_center_frequency())
-        self.add_capture_template(Modes.SWEPT_CENTER_FREQUENCY,
-                                  self._get_capture_template_swept_center_frequency())
-        
-    
-    def _add_pvalidators(self):
-        self.add_pvalidator(Modes.FIXED_CENTER_FREQUENCY,
-                            self._get_pvalidator_fixed_center_frequency())
-        self.add_pvalidator(Modes.SWEPT_CENTER_FREQUENCY,
-                            self._get_pvalidator_swept_center_frequency())