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

spectre_core/receivers/plugins/gr/_usrp.py

@@ -1,4 +1,4 @@
-# 
+#
 # USRP top blocks
 #
 
@@ -7,6 +7,7 @@ from dataclasses import dataclass
 import time
 
 from logging import getLogger
+
 _LOGGER = getLogger(__name__)
 
 from spectre_core.capture_configs import Parameters, PName
@@ -15,32 +16,28 @@ from ._base import capture, spectre_top_block
 
 
 class _fixed_center_frequency(spectre_top_block):
-    def flowgraph(
-        self,
-        tag: str,
-        parameters: Parameters
-    ) -> None:
+    def flowgraph(self, tag: str, parameters: Parameters) -> None:
         # OOT moudle inline imports
         from gnuradio import spectre
         from gnuradio import uhd
 
-        # Unpack capture config parameters 
-        sample_rate       = parameters.get_parameter_value(PName.SAMPLE_RATE)
-        gain              = parameters.get_parameter_value(PName.GAIN)
-        center_freq       = parameters.get_parameter_value(PName.CENTER_FREQUENCY)
+        # Unpack capture config parameters
+        sample_rate = parameters.get_parameter_value(PName.SAMPLE_RATE)
+        gain = parameters.get_parameter_value(PName.GAIN)
+        center_freq = parameters.get_parameter_value(PName.CENTER_FREQUENCY)
         master_clock_rate = parameters.get_parameter_value(PName.MASTER_CLOCK_RATE)
-        wire_format       = parameters.get_parameter_value(PName.WIRE_FORMAT)
-        batch_size        = parameters.get_parameter_value(PName.BATCH_SIZE)
-        bandwidth         = parameters.get_parameter_value(PName.BANDWIDTH) 
+        wire_format = parameters.get_parameter_value(PName.WIRE_FORMAT)
+        batch_size = parameters.get_parameter_value(PName.BATCH_SIZE)
+        bandwidth = parameters.get_parameter_value(PName.BANDWIDTH)
 
         # Blocks
-        master_clock_rate = f"master_clock_rate={master_clock_rate}" 
+        master_clock_rate = f"master_clock_rate={master_clock_rate}"
         self.uhd_usrp_source_0 = uhd.usrp_source(
-            ",".join(("", '', master_clock_rate)),
+            ",".join(("", "", master_clock_rate)),
             uhd.stream_args(
                 cpu_format="fc32",
                 otw_format=wire_format,
-                args='',
+                args="",
                 channels=[0],
             ),
         )
@@ -54,51 +51,47 @@ class _fixed_center_frequency(spectre_top_block):
         self.uhd_usrp_source_0.set_auto_dc_offset(False, 0)
         self.uhd_usrp_source_0.set_auto_iq_balance(False, 0)
         self.uhd_usrp_source_0.set_gain(gain, 0)
-        self.spectre_batched_file_sink_0 = spectre.batched_file_sink(get_batches_dir_path(), 
-                                                                     tag, 
-                                                                     batch_size, 
-                                                                     sample_rate, False, 
-                                                                     'rx_freq', 
-                                                                     0)
-
+        self.spectre_batched_file_sink_0 = spectre.batched_file_sink(
+            get_batches_dir_path(), tag, batch_size, sample_rate, False, "rx_freq", 0
+        )
 
         # Connections
         self.connect((self.uhd_usrp_source_0, 0), (self.spectre_batched_file_sink_0, 0))
 
 
 class _swept_center_frequency(spectre_top_block):
-    def flowgraph(
-        self,
-        tag: str,
-        parameters: Parameters
-    ) -> None:
+    def flowgraph(self, tag: str, parameters: Parameters) -> None:
         # OOT module inline imports
         from gnuradio import spectre
         from gnuradio import uhd
 
         # Unpack 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)
+        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)
         master_clock_rate = parameters.get_parameter_value(PName.MASTER_CLOCK_RATE)
-        master_clock_rate = master_clock_rate = parameters.get_parameter_value(PName.MASTER_CLOCK_RATE)
-        wire_format       = parameters.get_parameter_value(PName.WIRE_FORMAT)
-        gain              = parameters.get_parameter_value(PName.GAIN)
-        batch_size        = parameters.get_parameter_value(PName.BATCH_SIZE)
+        master_clock_rate = master_clock_rate = parameters.get_parameter_value(
+            PName.MASTER_CLOCK_RATE
+        )
+        wire_format = parameters.get_parameter_value(PName.WIRE_FORMAT)
+        gain = parameters.get_parameter_value(PName.GAIN)
+        batch_size = parameters.get_parameter_value(PName.BATCH_SIZE)
 
         # Blocks
-        _LOGGER.warning(f"USRP frequency sweep modes will not work as expected until a known bug is fixed in the USRP source block. "
-                        f"Please refer to this GitHub issue for more information: https://github.com/gnuradio/gnuradio/issues/7725")
-        master_clock_rate = f"master_clock_rate={master_clock_rate}" 
+        _LOGGER.warning(
+            f"USRP frequency sweep modes will not work as expected until a known bug is fixed in the USRP source block. "
+            f"Please refer to this GitHub issue for more information: https://github.com/gnuradio/gnuradio/issues/7725"
+        )
+        master_clock_rate = f"master_clock_rate={master_clock_rate}"
         self.uhd_usrp_source_0 = uhd.usrp_source(
-            ",".join(("", '', master_clock_rate)),
+            ",".join(("", "", master_clock_rate)),
             uhd.stream_args(
                 cpu_format="fc32",
                 otw_format=wire_format,
-                args='',
+                args="",
                 channels=[0],
             ),
         )
@@ -112,23 +105,30 @@ class _swept_center_frequency(spectre_top_block):
         self.uhd_usrp_source_0.set_auto_iq_balance(False, 0)
         self.uhd_usrp_source_0.set_gain(gain, 0)
 
-        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, 
-                                                                     'rx_freq', 
-                                                                     min_frequency)
+        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,
+            "rx_freq",
+            min_frequency,
+        )
 
         # Connections
-        self.msg_connect((self.spectre_sweep_driver_0, 'retune_command'), (self.uhd_usrp_source_0, 'command'))
+        self.msg_connect(
+            (self.spectre_sweep_driver_0, "retune_command"),
+            (self.uhd_usrp_source_0, "command"),
+        )
         self.connect((self.uhd_usrp_source_0, 0), (self.spectre_batched_file_sink_0, 0))
         self.connect((self.uhd_usrp_source_0, 0), (self.spectre_sweep_driver_0, 0))
 
@@ -136,4 +136,6 @@ class _swept_center_frequency(spectre_top_block):
 @dataclass(frozen=True)
 class CaptureMethod:
     fixed_center_frequency = partial(capture, top_block_cls=_fixed_center_frequency)
-    swept_center_frequency = partial(capture, top_block_cls=_swept_center_frequency, max_noutput_items=1024)
+    swept_center_frequency = partial(
+        capture, top_block_cls=_swept_center_frequency, max_noutput_items=1024
+    )

spectre_core/spectrograms/__init__.py

@@ -4,20 +4,28 @@
 
 """Create and transform spectrogram data."""
 
-from ._analytical import (
-    get_analytical_spectrogram, validate_analytically, TestResults
-)
-from ._spectrogram import (
-    Spectrogram, FrequencyCut, TimeCut, SpectrumUnit, TimeType
-)
+from ._analytical import get_analytical_spectrogram, validate_analytically, TestResults
+from ._spectrogram import Spectrogram, FrequencyCut, TimeCut, SpectrumUnit, TimeType
 from ._transform import (
-    frequency_chop, time_chop, frequency_average, time_average, 
-    join_spectrograms
+    frequency_chop,
+    time_chop,
+    frequency_average,
+    time_average,
+    join_spectrograms,
 )
 
 __all__ = [
-    "get_analytical_spectrogram", "validate_analytically", "TestResults",
-    "Spectrogram", "FrequencyCut", "TimeCut", "SpectrumUnit", "frequency_chop",
-    "time_chop", "frequency_average","time_average", "join_spectrograms",
-    "TimeType"
-]
+    "get_analytical_spectrogram",
+    "validate_analytically",
+    "TestResults",
+    "Spectrogram",
+    "FrequencyCut",
+    "TimeCut",
+    "SpectrumUnit",
+    "frequency_chop",
+    "time_chop",
+    "frequency_average",
+    "time_average",
+    "join_spectrograms",
+    "TimeType",
+]

spectre_core/spectrograms/_analytical.py

@@ -1,4 +1,3 @@
-
 # SPDX-FileCopyrightText: © 2024-2025 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
 # This file is part of SPECTRE
 # SPDX-License-Identifier: GPL-3.0-or-later
@@ -13,6 +12,7 @@ from spectre_core.exceptions import ModeNotFoundError
 from ._spectrogram import Spectrogram, SpectrumUnit
 from ._array_operations import is_close
 
+
 @dataclass
 class TestResults:
     """
@@ -22,73 +22,56 @@ class TestResults:
     :ivar frequencies_validated: Whether the frequency arrays match.
     :ivar spectrum_validated: Maps the relative time of each spectrum to its match results.
     """
+
     times_validated: bool = False
     frequencies_validated: bool = False
     spectrum_validated: dict[float, bool] = field(default_factory=dict)
 
     @property
-    def num_validated_spectrums(
-        self
-    ) -> int:
+    def num_validated_spectrums(self) -> int:
         """Returns the count of spectrums that successfully passed validation."""
         return sum(is_validated for is_validated in self.spectrum_validated.values())
 
-
     @property
-    def num_invalid_spectrums(
-        self
-    ) -> int:
+    def num_invalid_spectrums(self) -> int:
         """Returns the count of spectrums that failed validation."""
         return len(self.spectrum_validated) - self.num_validated_spectrums
-    
-    
-    def to_dict(
-        self
-    ) -> dict[str, bool | dict[float, bool]]:
+
+    def to_dict(self) -> dict[str, bool | dict[float, bool]]:
         """Converts the instance into a serialisable dictionary."""
         return {
-            "times_validated"      : self.times_validated,
+            "times_validated": self.times_validated,
             "frequencies_validated": self.frequencies_validated,
-            "spectrum_validated"   : self.spectrum_validated
+            "spectrum_validated": self.spectrum_validated,
         }
 
 
 class _AnalyticalFactory:
     """Factory for creating analytical spectrograms."""
-    def __init__(
-        self
-    ) -> None:
+
+    def __init__(self) -> None:
         """Initialises an instance of the `_AnalyticalFactory` class."""
         self._builders: dict[str, Callable[[int, CaptureConfig], Spectrogram]] = {
-            "cosine_signal_1" : self._cosine_signal_1,
-            "tagged_staircase": self._tagged_staircase
+            "cosine_signal_1": self._cosine_signal_1,
+            "tagged_staircase": self._tagged_staircase,
         }
 
-
     @property
-    def builders(
-        self
-    ) -> dict[str, Callable[[int, CaptureConfig], Spectrogram]]:
+    def builders(self) -> dict[str, Callable[[int, CaptureConfig], Spectrogram]]:
         """
         Provides a mapping from each `Test` receiver mode to its corresponding builder method.
 
         Each builder method generates the expected spectrograms for a session run in the associated mode.
         """
         return self._builders
-    
 
     @property
-    def test_modes(
-        self
-    ) -> list[str]:
+    def test_modes(self) -> list[str]:
         """Returns the available modes for the `Test` receiver."""
         return list(self.builders.keys())
-    
 
     def get_spectrogram(
-        self, 
-        num_spectrums: int, 
-        capture_config: CaptureConfig
+        self, num_spectrums: int, capture_config: CaptureConfig
     ) -> Spectrogram:
         """
         Generates an analytical spectrogram based on the capture config for a `Test` receiver.
@@ -101,29 +84,31 @@ class _AnalyticalFactory:
         :return: The expected spectrogram for running a session with the `Test` receiver in the specified mode.
         """
         if capture_config.receiver_name != "test":
-            raise ValueError(f"Input capture config must correspond to the test receiver")
-        
+            raise ValueError(
+                f"Input capture config must correspond to the test receiver"
+            )
+
         builder_method = self.builders.get(capture_config.receiver_mode)
         if builder_method is None:
-            raise ModeNotFoundError(f"Test mode not found. Expected one of '{self.test_modes}', but received '{capture_config.receiver_mode}'")
-        return builder_method(num_spectrums, 
-                              capture_config)
-    
+            raise ModeNotFoundError(
+                f"Test mode not found. Expected one of '{self.test_modes}', but received '{capture_config.receiver_mode}'"
+            )
+        return builder_method(num_spectrums, capture_config)
 
     def _cosine_signal_1(
-        self, 
-        num_spectrums: int,
-        capture_config: CaptureConfig
+        self, num_spectrums: int, capture_config: CaptureConfig
     ) -> Spectrogram:
         """Creates the expected spectrogram for the `Test` receiver operating in the mode `cosine-signal-1`."""
         # Extract necessary parameters from the capture config.
-        window_size      = cast(int,   capture_config.get_parameter_value(PName.WINDOW_SIZE))
-        sample_rate      = cast(int,   capture_config.get_parameter_value(PName.SAMPLE_RATE))
-        frequency        = cast(int,   capture_config.get_parameter_value(PName.FREQUENCY))
-        window_hop       = cast(int,   capture_config.get_parameter_value(PName.WINDOW_HOP))
-        amplitude        = cast(float, capture_config.get_parameter_value(PName.AMPLITUDE))
-        center_frequency = cast(float, capture_config.get_parameter_value(PName.CENTER_FREQUENCY))
-        
+        window_size = cast(int, capture_config.get_parameter_value(PName.WINDOW_SIZE))
+        sample_rate = cast(int, capture_config.get_parameter_value(PName.SAMPLE_RATE))
+        frequency = cast(int, capture_config.get_parameter_value(PName.FREQUENCY))
+        window_hop = cast(int, capture_config.get_parameter_value(PName.WINDOW_HOP))
+        amplitude = cast(float, capture_config.get_parameter_value(PName.AMPLITUDE))
+        center_frequency = cast(
+            float, capture_config.get_parameter_value(PName.CENTER_FREQUENCY)
+        )
+
         # Calculate derived parameters a (sampling rate ratio) and p (sampled periods).
         a = int(sample_rate / frequency)
         p = int(window_size / a)
@@ -138,38 +123,50 @@ class _AnalyticalFactory:
         spectrum = np.fft.fftshift(spectrum)
 
         # Populate the spectrogram with identical spectra.
-        analytical_dynamic_spectra = np.ones((window_size, num_spectrums)) * spectrum[:, np.newaxis]
+        analytical_dynamic_spectra = (
+            np.ones((window_size, num_spectrums)) * spectrum[:, np.newaxis]
+        )
 
         # Compute time array.
         sampling_interval = 1 / sample_rate
         times = np.arange(num_spectrums) * window_hop * sampling_interval
 
         # compute the frequency array.
-        frequencies = np.fft.fftshift(np.fft.fftfreq(window_size, sampling_interval)) + center_frequency
+        frequencies = (
+            np.fft.fftshift(np.fft.fftfreq(window_size, sampling_interval))
+            + center_frequency
+        )
 
         # Return the spectrogram.
-        return Spectrogram(analytical_dynamic_spectra,
-                           times,
-                           frequencies,
-                           'analytically-derived-spectrogram',
-                           SpectrumUnit.AMPLITUDE)
-
+        return Spectrogram(
+            analytical_dynamic_spectra,
+            times,
+            frequencies,
+            "analytically-derived-spectrogram",
+            SpectrumUnit.AMPLITUDE,
+        )
 
     def _tagged_staircase(
-        self, 
-        num_spectrums: int,
-        capture_config: CaptureConfig
+        self, num_spectrums: int, capture_config: CaptureConfig
     ) -> Spectrogram:
         """Creates the expected spectrogram for the `Test` receiver operating in the mode `tagged-staircase`."""
         # Extract necessary parameters from the capture config.
-        window_size          = cast(int, capture_config.get_parameter_value(PName.WINDOW_SIZE))
-        min_samples_per_step = cast(int, capture_config.get_parameter_value(PName.MIN_SAMPLES_PER_STEP))
-        max_samples_per_step = cast(int, capture_config.get_parameter_value(PName.MAX_SAMPLES_PER_STEP))
-        step_increment       = cast(int, capture_config.get_parameter_value(PName.STEP_INCREMENT))
-        samp_rate            = cast(int, capture_config.get_parameter_value(PName.SAMPLE_RATE))
+        window_size = cast(int, capture_config.get_parameter_value(PName.WINDOW_SIZE))
+        min_samples_per_step = cast(
+            int, capture_config.get_parameter_value(PName.MIN_SAMPLES_PER_STEP)
+        )
+        max_samples_per_step = cast(
+            int, capture_config.get_parameter_value(PName.MAX_SAMPLES_PER_STEP)
+        )
+        step_increment = cast(
+            int, capture_config.get_parameter_value(PName.STEP_INCREMENT)
+        )
+        samp_rate = cast(int, capture_config.get_parameter_value(PName.SAMPLE_RATE))
 
         # Calculate step sizes and derived parameters.
-        num_samples_per_step = np.arange(min_samples_per_step, max_samples_per_step + 1, step_increment)
+        num_samples_per_step = np.arange(
+            min_samples_per_step, max_samples_per_step + 1, step_increment
+        )
         num_steps = len(num_samples_per_step)
 
         # Create the analytical spectrum, constant in time.
@@ -178,42 +175,52 @@ class _AnalyticalFactory:
         for i in range(num_steps):
             step_count += 1
             spectral_amplitude = window_size * step_count
-            spectrum[int(window_size/2) + i*window_size] = spectral_amplitude
+            spectrum[int(window_size / 2) + i * window_size] = spectral_amplitude
 
         # Populate the spectrogram with identical spectra.
-        analytical_dynamic_spectra = np.ones((window_size * num_steps, num_spectrums)) * spectrum[:, np.newaxis]
+        analytical_dynamic_spectra = (
+            np.ones((window_size * num_steps, num_spectrums)) * spectrum[:, np.newaxis]
+        )
 
         # Compute time array
         num_samples_per_sweep = sum(num_samples_per_step)
         sampling_interval = 1 / samp_rate
         # compute the sample index we are "assigning" to each spectrum
         # and multiply by the sampling interval to get the equivalent physical time
-        times = np.array([(i * num_samples_per_sweep) for i in range(num_spectrums) ]) * sampling_interval
+        times = (
+            np.array([(i * num_samples_per_sweep) for i in range(num_spectrums)])
+            * sampling_interval
+        )
 
         # Compute the frequency array
-        baseband_frequencies = np.fft.fftshift(np.fft.fftfreq(window_size, sampling_interval))
+        baseband_frequencies = np.fft.fftshift(
+            np.fft.fftfreq(window_size, sampling_interval)
+        )
         frequencies = np.empty((window_size * num_steps), dtype=np.float32)
         for i in range(num_steps):
             lower_bound = i * window_size
             upper_bound = (i + 1) * window_size
-            frequencies[lower_bound:upper_bound] = baseband_frequencies + (samp_rate / 2) + (samp_rate * i)
+            frequencies[lower_bound:upper_bound] = (
+                baseband_frequencies + (samp_rate / 2) + (samp_rate * i)
+            )
 
         # Return the spectrogram.
-        return Spectrogram(analytical_dynamic_spectra,
-                           times,
-                           frequencies,
-                           'analytically-derived-spectrogram',
-                           SpectrumUnit.AMPLITUDE)
-    
+        return Spectrogram(
+            analytical_dynamic_spectra,
+            times,
+            frequencies,
+            "analytically-derived-spectrogram",
+            SpectrumUnit.AMPLITUDE,
+        )
+
 
 def get_analytical_spectrogram(
-    num_spectrums: int,
-    capture_config: CaptureConfig
+    num_spectrums: int, capture_config: CaptureConfig
 ) -> Spectrogram:
-    """Each mode of the `Test` receiver generates a known synthetic signal. Based on this, we can 
-    derive an analytical solution that predicts the expected spectrogram for a session in that mode. 
-    
-    This function constructs the analytical spectrogram using the capture config for a `Test` 
+    """Each mode of the `Test` receiver generates a known synthetic signal. Based on this, we can
+    derive an analytical solution that predicts the expected spectrogram for a session in that mode.
+
+    This function constructs the analytical spectrogram using the capture config for a `Test`
     receiver operating in a specific mode.
 
     :param num_spectrums: The number of spectrums in the output spectrogram.
@@ -221,14 +228,11 @@ def get_analytical_spectrogram(
     :return: The expected, analytically derived spectrogram for the specified mode of the `Test` receiver.
     """
     factory = _AnalyticalFactory()
-    return factory.get_spectrogram(num_spectrums,
-                                   capture_config)
+    return factory.get_spectrogram(num_spectrums, capture_config)
 
 
 def validate_analytically(
-    spectrogram: Spectrogram,
-    capture_config: CaptureConfig,
-    absolute_tolerance: float
+    spectrogram: Spectrogram, capture_config: CaptureConfig, absolute_tolerance: float
 ) -> TestResults:
     """Validate a spectrogram generated during sessions with a `Test` receiver operating
     in a particular mode.
@@ -238,26 +242,31 @@ def validate_analytically(
     :param absolute_tolerance: Tolerance level for numerical comparisons.
     :return: A `TestResults` object summarising the validation outcome.
     """
-    analytical_spectrogram = get_analytical_spectrogram(spectrogram.num_times,
-                                                        capture_config)
+    analytical_spectrogram = get_analytical_spectrogram(
+        spectrogram.num_times, capture_config
+    )
 
     test_results = TestResults()
 
-    test_results.times_validated = bool(is_close(analytical_spectrogram.times,
-                                                 spectrogram.times,
-                                                 absolute_tolerance))
+    test_results.times_validated = bool(
+        is_close(analytical_spectrogram.times, spectrogram.times, absolute_tolerance)
+    )
 
-    test_results.frequencies_validated = bool(is_close(analytical_spectrogram.frequencies,
-                                                       spectrogram.frequencies,
-                                                       absolute_tolerance))
+    test_results.frequencies_validated = bool(
+        is_close(
+            analytical_spectrogram.frequencies,
+            spectrogram.frequencies,
+            absolute_tolerance,
+        )
+    )
 
     test_results.spectrum_validated = {}
     for i in range(spectrogram.num_times):
         time = spectrogram.times[i]
         analytical_spectrum = analytical_spectrogram.dynamic_spectra[:, i]
         spectrum = spectrogram.dynamic_spectra[:, i]
-        test_results.spectrum_validated[time] = bool(is_close(analytical_spectrum, 
-                                                              spectrum,
-                                                              absolute_tolerance))
+        test_results.spectrum_validated[time] = bool(
+            is_close(analytical_spectrum, spectrum, absolute_tolerance)
+        )
 
-    return test_results
+    return test_results