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

spectre_core/receivers/plugins/_test.py

@@ -6,9 +6,15 @@ from dataclasses import dataclass
 from typing import Callable, cast
 
 from spectre_core.capture_configs import (
-    CaptureTemplate, CaptureMode, Parameters, Bound, PName,
-    get_base_capture_template, make_base_capture_template, get_base_ptemplate,
-    validate_window
+    CaptureTemplate,
+    CaptureMode,
+    Parameters,
+    Bound,
+    PName,
+    get_base_capture_template,
+    make_base_capture_template,
+    get_base_ptemplate,
+    validate_window,
 )
 from .gr._test import CaptureMethod
 from ._receiver_names import ReceiverName
@@ -20,137 +26,123 @@ from .._register import register_receiver
 @dataclass(frozen=True)
 class Mode:
     """An operating mode for the `Test` receiver."""
-    COSINE_SIGNAL_1  = "cosine_signal_1"
+
+    COSINE_SIGNAL_1 = "cosine_signal_1"
     TAGGED_STAIRCASE = "tagged_staircase"
 
 
 @register_receiver(ReceiverName.TEST)
 class Test(BaseReceiver):
     """An entirely software-defined receiver, which generates synthetic signals."""
-    def _add_specs(
-        self
-    ) -> None:
-        self.add_spec( SpecName.SAMPLE_RATE_LOWER_BOUND, 64000  )
-        self.add_spec( SpecName.SAMPLE_RATE_UPPER_BOUND, 640000 )
-        self.add_spec( SpecName.FREQUENCY_LOWER_BOUND  , 16000  )
-        self.add_spec( SpecName.FREQUENCY_UPPER_BOUND  , 160000 )
-
-
-    def _add_capture_methods(
-        self
-    ) -> None:
-        self.add_capture_method(Mode.COSINE_SIGNAL_1 , 
-                                CaptureMethod.cosine_signal_1 )
-        self.add_capture_method(Mode.TAGGED_STAIRCASE, 
-                                CaptureMethod.tagged_staircase)
-    
-
-    def _add_pvalidators(
-        self
-    ) -> None:
-        self.add_pvalidator(Mode.COSINE_SIGNAL_1 , 
-                            self.__get_pvalidator_cosine_signal_1()  )
-        self.add_pvalidator(Mode.TAGGED_STAIRCASE, 
-                            self.__get_pvalidator_tagged_staircase() )
-
-
-    def _add_capture_templates(
-        self
-    ) -> None:
-        self.add_capture_template(Mode.COSINE_SIGNAL_1 , 
-                                  self.__get_capture_template_cosine_signal_1()  )
-        self.add_capture_template(Mode.TAGGED_STAIRCASE, 
-                                  self.__get_capture_template_tagged_staircase() )
-        
-
-    def __get_capture_template_cosine_signal_1(
-        self
-    ) -> CaptureTemplate:
-        capture_template = get_base_capture_template( CaptureMode.FIXED_CENTER_FREQUENCY )
-        capture_template.add_ptemplate( get_base_ptemplate(PName.AMPLITUDE) )
-        capture_template.add_ptemplate( get_base_ptemplate(PName.FREQUENCY) )
+
+    def _add_specs(self) -> None:
+        self.add_spec(SpecName.SAMPLE_RATE_LOWER_BOUND, 64000)
+        self.add_spec(SpecName.SAMPLE_RATE_UPPER_BOUND, 640000)
+        self.add_spec(SpecName.FREQUENCY_LOWER_BOUND, 16000)
+        self.add_spec(SpecName.FREQUENCY_UPPER_BOUND, 160000)
+
+    def _add_capture_methods(self) -> None:
+        self.add_capture_method(Mode.COSINE_SIGNAL_1, CaptureMethod.cosine_signal_1)
+        self.add_capture_method(Mode.TAGGED_STAIRCASE, CaptureMethod.tagged_staircase)
+
+    def _add_pvalidators(self) -> None:
+        self.add_pvalidator(
+            Mode.COSINE_SIGNAL_1, self.__get_pvalidator_cosine_signal_1()
+        )
+        self.add_pvalidator(
+            Mode.TAGGED_STAIRCASE, self.__get_pvalidator_tagged_staircase()
+        )
+
+    def _add_capture_templates(self) -> None:
+        self.add_capture_template(
+            Mode.COSINE_SIGNAL_1, self.__get_capture_template_cosine_signal_1()
+        )
+        self.add_capture_template(
+            Mode.TAGGED_STAIRCASE, self.__get_capture_template_tagged_staircase()
+        )
+
+    def __get_capture_template_cosine_signal_1(self) -> CaptureTemplate:
+        capture_template = get_base_capture_template(CaptureMode.FIXED_CENTER_FREQUENCY)
+        capture_template.add_ptemplate(get_base_ptemplate(PName.AMPLITUDE))
+        capture_template.add_ptemplate(get_base_ptemplate(PName.FREQUENCY))
 
         capture_template.set_defaults(
-            (PName.BATCH_SIZE,            3.0),
-            (PName.CENTER_FREQUENCY,      16000),
-            (PName.AMPLITUDE,             2.0),
-            (PName.FREQUENCY,             32000),
-            (PName.SAMPLE_RATE,           128000),
-            (PName.WINDOW_HOP,            512),
-            (PName.WINDOW_SIZE,           512),
-            (PName.WINDOW_TYPE,           "boxcar")
+            (PName.BATCH_SIZE, 3.0),
+            (PName.CENTER_FREQUENCY, 16000),
+            (PName.AMPLITUDE, 2.0),
+            (PName.FREQUENCY, 32000),
+            (PName.SAMPLE_RATE, 128000),
+            (PName.WINDOW_HOP, 512),
+            (PName.WINDOW_SIZE, 512),
+            (PName.WINDOW_TYPE, "boxcar"),
         )
 
         capture_template.enforce_defaults(
             PName.TIME_RESOLUTION,
             PName.TIME_RANGE,
             PName.FREQUENCY_RESOLUTION,
-            PName.WINDOW_TYPE
+            PName.WINDOW_TYPE,
         )
 
-
         capture_template.add_pconstraint(
             PName.SAMPLE_RATE,
             [
                 Bound(
                     lower_bound=self.get_spec(SpecName.SAMPLE_RATE_LOWER_BOUND),
-                    upper_bound=self.get_spec(SpecName.SAMPLE_RATE_UPPER_BOUND)
+                    upper_bound=self.get_spec(SpecName.SAMPLE_RATE_UPPER_BOUND),
                 )
-            ]
+            ],
         )
         capture_template.add_pconstraint(
             PName.FREQUENCY,
             [
                 Bound(
                     lower_bound=self.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
-                    upper_bound=self.get_spec(SpecName.FREQUENCY_UPPER_BOUND)
+                    upper_bound=self.get_spec(SpecName.FREQUENCY_UPPER_BOUND),
                 )
-            ]
+            ],
         )
         return capture_template
 
-
-    def __get_capture_template_tagged_staircase(
-        self
-    ) -> CaptureTemplate:
+    def __get_capture_template_tagged_staircase(self) -> CaptureTemplate:
         capture_template = make_base_capture_template(
-                PName.TIME_RESOLUTION,
-                PName.FREQUENCY_RESOLUTION,
-                PName.TIME_RANGE,
-                PName.SAMPLE_RATE,
-                PName.BATCH_SIZE,
-                PName.WINDOW_TYPE,
-                PName.WINDOW_HOP,
-                PName.WINDOW_SIZE,
-                PName.EVENT_HANDLER_KEY,
-                PName.BATCH_KEY,
-                PName.WATCH_EXTENSION,
-                PName.MIN_SAMPLES_PER_STEP,
-                PName.MAX_SAMPLES_PER_STEP,
-                PName.FREQUENCY_STEP,
-                PName.STEP_INCREMENT,
-                PName.OBS_ALT,
-                PName.OBS_LAT,
-                PName.OBS_LON,
-                PName.OBJECT,
-                PName.ORIGIN,
-                PName.TELESCOPE,
-                PName.INSTRUMENT
+            PName.TIME_RESOLUTION,
+            PName.FREQUENCY_RESOLUTION,
+            PName.TIME_RANGE,
+            PName.SAMPLE_RATE,
+            PName.BATCH_SIZE,
+            PName.WINDOW_TYPE,
+            PName.WINDOW_HOP,
+            PName.WINDOW_SIZE,
+            PName.EVENT_HANDLER_KEY,
+            PName.BATCH_KEY,
+            PName.WATCH_EXTENSION,
+            PName.MIN_SAMPLES_PER_STEP,
+            PName.MAX_SAMPLES_PER_STEP,
+            PName.FREQUENCY_STEP,
+            PName.STEP_INCREMENT,
+            PName.OBS_ALT,
+            PName.OBS_LAT,
+            PName.OBS_LON,
+            PName.OBJECT,
+            PName.ORIGIN,
+            PName.TELESCOPE,
+            PName.INSTRUMENT,
         )
 
         capture_template.set_defaults(
-            (PName.BATCH_SIZE,            3.0),
-            (PName.FREQUENCY_STEP,        128000),
-            (PName.MAX_SAMPLES_PER_STEP,  5000),
-            (PName.MIN_SAMPLES_PER_STEP,  4000),
-            (PName.SAMPLE_RATE,           128000),
-            (PName.STEP_INCREMENT,        200),
-            (PName.WINDOW_HOP,            512),
-            (PName.WINDOW_SIZE,           512),
-            (PName.WINDOW_TYPE,           "boxcar"),
-            (PName.EVENT_HANDLER_KEY,     "swept_center_frequency"),
-            (PName.BATCH_KEY,             "iq_stream"),
-            (PName.WATCH_EXTENSION,       "bin")
+            (PName.BATCH_SIZE, 3.0),
+            (PName.FREQUENCY_STEP, 128000),
+            (PName.MAX_SAMPLES_PER_STEP, 5000),
+            (PName.MIN_SAMPLES_PER_STEP, 4000),
+            (PName.SAMPLE_RATE, 128000),
+            (PName.STEP_INCREMENT, 200),
+            (PName.WINDOW_HOP, 512),
+            (PName.WINDOW_SIZE, 512),
+            (PName.WINDOW_TYPE, "boxcar"),
+            (PName.EVENT_HANDLER_KEY, "swept_center_frequency"),
+            (PName.BATCH_KEY, "iq_stream"),
+            (PName.WATCH_EXTENSION, "bin"),
         )
 
         capture_template.enforce_defaults(
@@ -160,59 +152,74 @@ class Test(BaseReceiver):
             PName.WINDOW_TYPE,
             PName.EVENT_HANDLER_KEY,
             PName.BATCH_KEY,
-            PName.WATCH_EXTENSION
+            PName.WATCH_EXTENSION,
         )
 
         return capture_template
-    
-    
-    def __get_pvalidator_cosine_signal_1(
-        self
-    ) -> Callable[[Parameters], None]:
+
+    def __get_pvalidator_cosine_signal_1(self) -> Callable[[Parameters], None]:
         def pvalidator(parameters: Parameters) -> None:
             validate_window(parameters)
 
-            sample_rate          = cast(int, parameters.get_parameter_value(PName.SAMPLE_RATE))
-            window_size          = cast(int, parameters.get_parameter_value(PName.WINDOW_SIZE))
-            frequency            = cast(float, parameters.get_parameter_value(PName.FREQUENCY))
+            sample_rate = cast(int, parameters.get_parameter_value(PName.SAMPLE_RATE))
+            window_size = cast(int, parameters.get_parameter_value(PName.WINDOW_SIZE))
+            frequency = cast(float, parameters.get_parameter_value(PName.FREQUENCY))
 
             # check that the sample rate is an integer multiple of the underlying signal frequency
             if sample_rate % frequency != 0:
-                raise ValueError("The sampling rate must be some integer multiple of frequency")
+                raise ValueError(
+                    "The sampling rate must be some integer multiple of frequency"
+                )
 
-            a = sample_rate/frequency
+            a = sample_rate / frequency
             if a < 2:
-                raise ValueError((f"The ratio of sampling rate over frequency must be greater than two. "
-                                f"Got {a}"))
-            
+                raise ValueError(
+                    (
+                        f"The ratio of sampling rate over frequency must be greater than two. "
+                        f"Got {a}"
+                    )
+                )
+
             # analytical requirement
             # if p is the number of sampled cycles, we can find that p = window_size / a
             # the number of sampled cycles must be a positive natural number.
             p = window_size / a
             if window_size % a != 0:
-                raise ValueError((f"The number of sampled cycles must be a positive natural number. "
-                                  f"Computed that p={p}"))
-        return pvalidator
+                raise ValueError(
+                    (
+                        f"The number of sampled cycles must be a positive natural number. "
+                        f"Computed that p={p}"
+                    )
+                )
 
+        return pvalidator
 
-    def __get_pvalidator_tagged_staircase(
-        self
-    ) -> Callable[[Parameters], None]:
+    def __get_pvalidator_tagged_staircase(self) -> Callable[[Parameters], None]:
         def pvalidator(parameters: Parameters) -> None:
             validate_window(parameters)
 
-            freq_step            = cast(float, parameters.get_parameter_value(PName.FREQUENCY_STEP))
-            sample_rate          = cast(int, parameters.get_parameter_value(PName.SAMPLE_RATE))
-            min_samples_per_step = cast(int, parameters.get_parameter_value(PName.MIN_SAMPLES_PER_STEP))
-            max_samples_per_step = cast(int, parameters.get_parameter_value(PName.MAX_SAMPLES_PER_STEP))
+            freq_step = cast(
+                float, parameters.get_parameter_value(PName.FREQUENCY_STEP)
+            )
+            sample_rate = cast(int, parameters.get_parameter_value(PName.SAMPLE_RATE))
+            min_samples_per_step = cast(
+                int, parameters.get_parameter_value(PName.MIN_SAMPLES_PER_STEP)
+            )
+            max_samples_per_step = cast(
+                int, parameters.get_parameter_value(PName.MAX_SAMPLES_PER_STEP)
+            )
 
             if freq_step != sample_rate:
-                raise ValueError(f"The frequency step must be equal to the sampling rate")
-            
-            
+                raise ValueError(
+                    f"The frequency step must be equal to the sampling rate"
+                )
+
             if min_samples_per_step > max_samples_per_step:
-                raise ValueError((f"Minimum samples per step cannot be greater than the maximum samples per step. "
-                                f"Got {min_samples_per_step}, which is greater than {max_samples_per_step}"))
-            
+                raise ValueError(
+                    (
+                        f"Minimum samples per step cannot be greater than the maximum samples per step. "
+                        f"Got {min_samples_per_step}, which is greater than {max_samples_per_step}"
+                    )
+                )
+
         return pvalidator
-        

spectre_core/receivers/plugins/_usrp.py

@@ -5,167 +5,176 @@
 from typing import Callable, overload
 
 from spectre_core.capture_configs import (
-    CaptureTemplate, CaptureMode, Parameters, Bound, PName,
-    get_base_capture_template, get_base_ptemplate, OneOf,
+    CaptureTemplate,
+    CaptureMode,
+    Parameters,
+    Bound,
+    PName,
+    get_base_capture_template,
+    get_base_ptemplate,
+    OneOf,
     validate_sample_rate_with_master_clock_rate,
-    validate_fixed_center_frequency, validate_swept_center_frequency
+    validate_fixed_center_frequency,
+    validate_swept_center_frequency,
 )
 from .._base import BaseReceiver
 from .._spec_names import SpecName
 
 
 def get_pvalidator_fixed_center_frequency(
-    usrp_receiver: BaseReceiver 
+    usrp_receiver: BaseReceiver,
 ) -> Callable[[Parameters], None]:
     def pvalidator(parameters: Parameters) -> None:
         validate_fixed_center_frequency(parameters)
         validate_sample_rate_with_master_clock_rate(parameters)
+
     return pvalidator
 
 
 def get_pvalidator_swept_center_frequency(
-    usrp_receiver: BaseReceiver 
+    usrp_receiver: BaseReceiver,
 ) -> Callable[[Parameters], None]:
     def pvalidator(parameters: Parameters) -> None:
-        validate_swept_center_frequency(parameters,
-                                        usrp_receiver.get_spec(SpecName.API_RETUNING_LATENCY))
+        validate_swept_center_frequency(
+            parameters, usrp_receiver.get_spec(SpecName.API_RETUNING_LATENCY)
+        )
         validate_sample_rate_with_master_clock_rate(parameters)
+
     return pvalidator
 
 
 def get_capture_template_fixed_center_frequency(
-    usrp_receiver: BaseReceiver
+    usrp_receiver: BaseReceiver,
 ) -> CaptureTemplate:
-    
-    capture_template = get_base_capture_template( CaptureMode.FIXED_CENTER_FREQUENCY )
-    capture_template.add_ptemplate( get_base_ptemplate(PName.BANDWIDTH) )
-    capture_template.add_ptemplate( get_base_ptemplate(PName.GAIN) )
-    capture_template.add_ptemplate( get_base_ptemplate(PName.WIRE_FORMAT) )
-    capture_template.add_ptemplate( get_base_ptemplate(PName.MASTER_CLOCK_RATE) ) 
+
+    capture_template = get_base_capture_template(CaptureMode.FIXED_CENTER_FREQUENCY)
+    capture_template.add_ptemplate(get_base_ptemplate(PName.BANDWIDTH))
+    capture_template.add_ptemplate(get_base_ptemplate(PName.GAIN))
+    capture_template.add_ptemplate(get_base_ptemplate(PName.WIRE_FORMAT))
+    capture_template.add_ptemplate(get_base_ptemplate(PName.MASTER_CLOCK_RATE))
 
     # TODO: Delegate defaults to receiver subclasses. Currently, these are sensible defaults for the b200mini
     capture_template.set_defaults(
-        (PName.BATCH_SIZE,            4.0),
-        (PName.CENTER_FREQUENCY,      95800000),
-        (PName.SAMPLE_RATE,           2000000),
-        (PName.BANDWIDTH,             2000000),
-        (PName.WINDOW_HOP,            512),
-        (PName.WINDOW_SIZE,           1024),
-        (PName.WINDOW_TYPE,           "blackman"),
-        (PName.GAIN,                  35),
-        (PName.WIRE_FORMAT,           "sc16"),
-        (PName.MASTER_CLOCK_RATE,     40e6)
-    )   
+        (PName.BATCH_SIZE, 4.0),
+        (PName.CENTER_FREQUENCY, 95800000),
+        (PName.SAMPLE_RATE, 2000000),
+        (PName.BANDWIDTH, 2000000),
+        (PName.WINDOW_HOP, 512),
+        (PName.WINDOW_SIZE, 1024),
+        (PName.WINDOW_TYPE, "blackman"),
+        (PName.GAIN, 35),
+        (PName.WIRE_FORMAT, "sc16"),
+        (PName.MASTER_CLOCK_RATE, 40e6),
+    )
 
     capture_template.add_pconstraint(
         PName.CENTER_FREQUENCY,
         [
             Bound(
                 lower_bound=usrp_receiver.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
-                upper_bound=usrp_receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND)
+                upper_bound=usrp_receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND),
             )
-        ]
+        ],
     )
     capture_template.add_pconstraint(
         PName.SAMPLE_RATE,
         [
             Bound(
                 lower_bound=usrp_receiver.get_spec(SpecName.SAMPLE_RATE_LOWER_BOUND),
-                upper_bound=usrp_receiver.get_spec(SpecName.SAMPLE_RATE_UPPER_BOUND)
+                upper_bound=usrp_receiver.get_spec(SpecName.SAMPLE_RATE_UPPER_BOUND),
             )
-        ]
+        ],
     )
     capture_template.add_pconstraint(
         PName.BANDWIDTH,
         [
             Bound(
-                lower_bound=usrp_receiver.get_spec( SpecName.BANDWIDTH_LOWER_BOUND ),
-                upper_bound=usrp_receiver.get_spec( SpecName.BANDWIDTH_UPPER_BOUND )
+                lower_bound=usrp_receiver.get_spec(SpecName.BANDWIDTH_LOWER_BOUND),
+                upper_bound=usrp_receiver.get_spec(SpecName.BANDWIDTH_UPPER_BOUND),
             )
-        ]
+        ],
     )
     capture_template.add_pconstraint(
         PName.GAIN,
         [
             Bound(
                 lower_bound=0,
-                upper_bound=usrp_receiver.get_spec( SpecName.GAIN_UPPER_BOUND )
+                upper_bound=usrp_receiver.get_spec(SpecName.GAIN_UPPER_BOUND),
             )
-        ]
+        ],
     )
     capture_template.add_pconstraint(
-        PName.WIRE_FORMAT,
-        [
-            OneOf(
-                usrp_receiver.get_spec( SpecName.WIRE_FORMATS )
-            )
-        ]
+        PName.WIRE_FORMAT, [OneOf(usrp_receiver.get_spec(SpecName.WIRE_FORMATS))]
     )
     capture_template.add_pconstraint(
         PName.MASTER_CLOCK_RATE,
         [
             Bound(
-                lower_bound=usrp_receiver.get_spec( SpecName.MASTER_CLOCK_RATE_LOWER_BOUND ),
-                upper_bound=usrp_receiver.get_spec( SpecName.MASTER_CLOCK_RATE_UPPER_BOUND )
+                lower_bound=usrp_receiver.get_spec(
+                    SpecName.MASTER_CLOCK_RATE_LOWER_BOUND
+                ),
+                upper_bound=usrp_receiver.get_spec(
+                    SpecName.MASTER_CLOCK_RATE_UPPER_BOUND
+                ),
             )
-        ]
+        ],
     )
     return capture_template
 
 
 def get_capture_template_swept_center_frequency(
-    usrp_receiver: BaseReceiver
+    usrp_receiver: BaseReceiver,
 ) -> CaptureTemplate:
 
-    capture_template = get_base_capture_template( CaptureMode.SWEPT_CENTER_FREQUENCY )
-    capture_template.add_ptemplate( get_base_ptemplate(PName.BANDWIDTH) )
-    capture_template.add_ptemplate( get_base_ptemplate(PName.GAIN) )
-    capture_template.add_ptemplate( get_base_ptemplate(PName.WIRE_FORMAT) )
-    capture_template.add_ptemplate( get_base_ptemplate(PName.MASTER_CLOCK_RATE) ) 
+    capture_template = get_base_capture_template(CaptureMode.SWEPT_CENTER_FREQUENCY)
+    capture_template.add_ptemplate(get_base_ptemplate(PName.BANDWIDTH))
+    capture_template.add_ptemplate(get_base_ptemplate(PName.GAIN))
+    capture_template.add_ptemplate(get_base_ptemplate(PName.WIRE_FORMAT))
+    capture_template.add_ptemplate(get_base_ptemplate(PName.MASTER_CLOCK_RATE))
 
     # TODO: Delegate defaults to receiver subclasses. Currently, these are sensible defaults for the b200mini
     capture_template.set_defaults(
-        (PName.BATCH_SIZE,            4.0),
-        (PName.MIN_FREQUENCY,         95000000),
-        (PName.MAX_FREQUENCY,         105000000),
-        (PName.SAMPLES_PER_STEP,      30000),
-        (PName.FREQUENCY_STEP,        2000000),
-        (PName.SAMPLE_RATE,           2000000),
-        (PName.BANDWIDTH,             2000000),
-        (PName.WINDOW_HOP,            512),
-        (PName.WINDOW_SIZE,           1024),
-        (PName.WINDOW_TYPE,           "blackman"),
-        (PName.GAIN,                  35),
-        (PName.WIRE_FORMAT,           "sc16"),
-        (PName.MASTER_CLOCK_RATE,     40e6)
-    )   
+        (PName.BATCH_SIZE, 4.0),
+        (PName.MIN_FREQUENCY, 95000000),
+        (PName.MAX_FREQUENCY, 105000000),
+        (PName.SAMPLES_PER_STEP, 30000),
+        (PName.FREQUENCY_STEP, 2000000),
+        (PName.SAMPLE_RATE, 2000000),
+        (PName.BANDWIDTH, 2000000),
+        (PName.WINDOW_HOP, 512),
+        (PName.WINDOW_SIZE, 1024),
+        (PName.WINDOW_TYPE, "blackman"),
+        (PName.GAIN, 35),
+        (PName.WIRE_FORMAT, "sc16"),
+        (PName.MASTER_CLOCK_RATE, 40e6),
+    )
 
     capture_template.add_pconstraint(
         PName.MIN_FREQUENCY,
         [
             Bound(
                 lower_bound=usrp_receiver.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
-                upper_bound=usrp_receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND)
+                upper_bound=usrp_receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND),
             )
-        ]
+        ],
     )
     capture_template.add_pconstraint(
         PName.MAX_FREQUENCY,
         [
             Bound(
                 lower_bound=usrp_receiver.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
-                upper_bound=usrp_receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND)
+                upper_bound=usrp_receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND),
             )
-        ]
+        ],
     )
     capture_template.add_pconstraint(
         PName.SAMPLE_RATE,
         [
             Bound(
                 lower_bound=usrp_receiver.get_spec(SpecName.SAMPLE_RATE_LOWER_BOUND),
-                upper_bound=usrp_receiver.get_spec(SpecName.SAMPLE_RATE_UPPER_BOUND)
+                upper_bound=usrp_receiver.get_spec(SpecName.SAMPLE_RATE_UPPER_BOUND),
             )
-        ]
+        ],
     )
     capture_template.add_pconstraint(
         PName.BANDWIDTH,
@@ -174,32 +183,31 @@ def get_capture_template_swept_center_frequency(
                 lower_bound=usrp_receiver.get_spec(SpecName.BANDWIDTH_LOWER_BOUND),
                 upper_bound=usrp_receiver.get_spec(SpecName.BANDWIDTH_UPPER_BOUND),
             )
-        ]
+        ],
     )
     capture_template.add_pconstraint(
         PName.GAIN,
         [
             Bound(
                 lower_bound=0,
-                upper_bound=usrp_receiver.get_spec( SpecName.GAIN_UPPER_BOUND )
+                upper_bound=usrp_receiver.get_spec(SpecName.GAIN_UPPER_BOUND),
             )
-        ]
+        ],
     )
     capture_template.add_pconstraint(
-        PName.WIRE_FORMAT,
-        [
-            OneOf(
-                usrp_receiver.get_spec( SpecName.WIRE_FORMATS )
-            )
-        ]
+        PName.WIRE_FORMAT, [OneOf(usrp_receiver.get_spec(SpecName.WIRE_FORMATS))]
     )
-    capture_template.add_pconstraint(                                                           
+    capture_template.add_pconstraint(
         PName.MASTER_CLOCK_RATE,
         [
-            Bound(                                                                              
-                lower_bound=usrp_receiver.get_spec( SpecName.MASTER_CLOCK_RATE_LOWER_BOUND ),   
-                upper_bound=usrp_receiver.get_spec( SpecName.MASTER_CLOCK_RATE_UPPER_BOUND )    
-            )                                                                                   
-        ]                                                                                       
-    )                                                                                           
+            Bound(
+                lower_bound=usrp_receiver.get_spec(
+                    SpecName.MASTER_CLOCK_RATE_LOWER_BOUND
+                ),
+                upper_bound=usrp_receiver.get_spec(
+                    SpecName.MASTER_CLOCK_RATE_UPPER_BOUND
+                ),
+            )
+        ],
+    )
     return capture_template

spectre_core/receivers/plugins/gr/__init__.py

@@ -1,3 +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
+# SPDX-License-Identifier: GPL-3.0-or-later