spectre-core 0.0.21__py3-none-any.whl → 0.0.23__py3-none-any.whl

spectre_core/receivers/plugins/_b200mini.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# SPDX-FileCopyrightText: © 2024-2025 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
 # This file is part of SPECTRE
 # SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -6,17 +6,21 @@ from dataclasses import dataclass
 
 from ._receiver_names import ReceiverName
 from ._usrp import (
-        get_pvalidator_fixed_center_frequency, get_pvalidator_swept_center_frequency,
-        get_capture_template_fixed_center_frequency, get_capture_template_swept_center_frequency
+    get_pvalidator_fixed_center_frequency,
+    get_pvalidator_swept_center_frequency,
+    get_capture_template_fixed_center_frequency,
+    get_capture_template_swept_center_frequency,
 )
 from .gr._usrp import CaptureMethod
 from .._spec_names import SpecName
 from .._base import BaseReceiver
-from .._register import register_receiver 
+from .._register import register_receiver
+
 
 @dataclass(frozen=True)
 class Mode:
     """An operating mode for the `B200mini` receiver."""
+
     FIXED_CENTER_FREQUENCY = "fixed_center_frequency"
     SWEPT_CENTER_FREQUENCY = "swept_center_frequency"
 
@@ -24,61 +28,44 @@ class Mode:
 @register_receiver(ReceiverName.B200MINI)
 class B200mini(BaseReceiver):
     """Receiver implementation for the USRP B200mini (https://www.ettus.com/all-products/usrp-b200mini/)"""
-    def _add_specs(
-        self
-    ) -> None:
-        self.add_spec( SpecName.SAMPLE_RATE_LOWER_BOUND      , 200e3 )
-        self.add_spec( SpecName.SAMPLE_RATE_UPPER_BOUND      , 56e6  )
-        self.add_spec( SpecName.FREQUENCY_LOWER_BOUND        , 70e6  )
-        self.add_spec( SpecName.FREQUENCY_UPPER_BOUND        , 6e9   )
-        self.add_spec( SpecName.BANDWIDTH_LOWER_BOUND        , 200e3 ) 
-        self.add_spec( SpecName.BANDWIDTH_UPPER_BOUND        , 56e6  )
-        self.add_spec( SpecName.GAIN_UPPER_BOUND             , 76    )
-        self.add_spec( SpecName.WIRE_FORMATS                 , ["sc8", "sc12", "sc16"])
-        self.add_spec( SpecName.MASTER_CLOCK_RATE_LOWER_BOUND, 5e6)
-        self.add_spec( SpecName.MASTER_CLOCK_RATE_UPPER_BOUND, 61.44e6)
-        self.add_spec( SpecName.API_RETUNING_LATENCY         , 1e-5  ) # TODO: This is a ballpark, pending empirical testing 
-
-   
-    def _add_capture_methods(
-        self
-    ) -> None:
-       self.add_capture_method(Mode.FIXED_CENTER_FREQUENCY,
-                               CaptureMethod.fixed_center_frequency)
-       self.add_capture_method(Mode.SWEPT_CENTER_FREQUENCY,
-                               CaptureMethod.swept_center_frequency)
-
-   
-    def _add_capture_templates(
-        self
-    ) -> None:
-        self.add_capture_template(Mode.FIXED_CENTER_FREQUENCY,
-                                  get_capture_template_fixed_center_frequency(self))
-        self.add_capture_template(Mode.SWEPT_CENTER_FREQUENCY,
-                                  get_capture_template_swept_center_frequency(self))
-
-
-    def _add_pvalidators(
-        self
-    ) -> None:
-        self.add_pvalidator(Mode.FIXED_CENTER_FREQUENCY,
-                            get_pvalidator_fixed_center_frequency(self))
-        self.add_pvalidator(Mode.SWEPT_CENTER_FREQUENCY,
-                            get_pvalidator_swept_center_frequency(self))
-
-    
- 
-
-
-
-
-
-
-
-
-
-
-
-
-
 
+    def _add_specs(self) -> None:
+        self.add_spec(SpecName.SAMPLE_RATE_LOWER_BOUND, 200e3)
+        self.add_spec(SpecName.SAMPLE_RATE_UPPER_BOUND, 56e6)
+        self.add_spec(SpecName.FREQUENCY_LOWER_BOUND, 70e6)
+        self.add_spec(SpecName.FREQUENCY_UPPER_BOUND, 6e9)
+        self.add_spec(SpecName.BANDWIDTH_LOWER_BOUND, 200e3)
+        self.add_spec(SpecName.BANDWIDTH_UPPER_BOUND, 56e6)
+        self.add_spec(SpecName.GAIN_UPPER_BOUND, 76)
+        self.add_spec(SpecName.WIRE_FORMATS, ["sc8", "sc12", "sc16"])
+        self.add_spec(SpecName.MASTER_CLOCK_RATE_LOWER_BOUND, 5e6)
+        self.add_spec(SpecName.MASTER_CLOCK_RATE_UPPER_BOUND, 61.44e6)
+        self.add_spec(
+            SpecName.API_RETUNING_LATENCY, 1e-5
+        )  # TODO: This is a ballpark, pending empirical testing
+
+    def _add_capture_methods(self) -> None:
+        self.add_capture_method(
+            Mode.FIXED_CENTER_FREQUENCY, CaptureMethod.fixed_center_frequency
+        )
+        self.add_capture_method(
+            Mode.SWEPT_CENTER_FREQUENCY, CaptureMethod.swept_center_frequency
+        )
+
+    def _add_capture_templates(self) -> None:
+        self.add_capture_template(
+            Mode.FIXED_CENTER_FREQUENCY,
+            get_capture_template_fixed_center_frequency(self),
+        )
+        self.add_capture_template(
+            Mode.SWEPT_CENTER_FREQUENCY,
+            get_capture_template_swept_center_frequency(self),
+        )
+
+    def _add_pvalidators(self) -> None:
+        self.add_pvalidator(
+            Mode.FIXED_CENTER_FREQUENCY, get_pvalidator_fixed_center_frequency(self)
+        )
+        self.add_pvalidator(
+            Mode.SWEPT_CENTER_FREQUENCY, get_pvalidator_swept_center_frequency(self)
+        )

spectre_core/receivers/plugins/_receiver_names.py

@@ -1,18 +1,20 @@
-# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# SPDX-FileCopyrightText: © 2024-2025 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
 # This file is part of SPECTRE
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 from enum import Enum
 
-class ReceiverName(Enum):  
+
+class ReceiverName(Enum):
     """A `spectre` supported receiver.
-    
+
     :ivar RSP1A: SDRPlay RSP1A
     :ivar RSPDUO: SDRPlay RSPduo
     :ivar TEST: `spectre` test receiver.
     :ivar B200MINI: USRP B200mini.
     """
-    RSP1A     = "rsp1a"
-    RSPDUO    = "rspduo"
-    TEST      = "test"
-    B200MINI =  "b200mini"
+
+    RSP1A = "rsp1a"
+    RSPDUO = "rspduo"
+    TEST = "test"
+    B200MINI = "b200mini"

spectre_core/receivers/plugins/_rsp1a.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# SPDX-FileCopyrightText: © 2024-2025 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
 # This file is part of SPECTRE
 # SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -7,59 +7,63 @@ from dataclasses import dataclass
 from ._receiver_names import ReceiverName
 from .gr._rsp1a import CaptureMethod
 from ._sdrplay_receiver import (
-    get_pvalidator_fixed_center_frequency, get_pvalidator_swept_center_frequency,
-    get_capture_template_fixed_center_frequency, get_capture_template_swept_center_frequency
+    get_pvalidator_fixed_center_frequency,
+    get_pvalidator_swept_center_frequency,
+    get_capture_template_fixed_center_frequency,
+    get_capture_template_swept_center_frequency,
 )
 from .._spec_names import SpecName
 from .._base import BaseReceiver
 from .._register import register_receiver
 
+
 @dataclass(frozen=True)
 class Mode:
     """An operating mode for the `RSP1A` receiver."""
-    FIXED_CENTER_FREQUENCY  = "fixed_center_frequency"
-    SWEPT_CENTER_FREQUENCY  = "swept_center_frequency"
+
+    FIXED_CENTER_FREQUENCY = "fixed_center_frequency"
+    SWEPT_CENTER_FREQUENCY = "swept_center_frequency"
 
 
 @register_receiver(ReceiverName.RSP1A)
 class RSP1A(BaseReceiver):
     """Receiver implementation for the SDRPlay RSP1A (https://www.sdrplay.com/rsp1a/)"""
-    def _add_specs(
-            self
-    ) -> None:
-        self.add_spec( SpecName.SAMPLE_RATE_LOWER_BOUND, 200e3     )
-        self.add_spec( SpecName.SAMPLE_RATE_UPPER_BOUND, 10e6      )
-        self.add_spec( SpecName.FREQUENCY_LOWER_BOUND  , 1e3       )
-        self.add_spec( SpecName.FREQUENCY_UPPER_BOUND  , 2e9       )
-        self.add_spec( SpecName.IF_GAIN_UPPER_BOUND    , -20       )
-        self.add_spec( SpecName.RF_GAIN_UPPER_BOUND    , 0         )
-        self.add_spec( SpecName.API_RETUNING_LATENCY   , 50 * 1e-3 )
-        self.add_spec( SpecName.BANDWIDTH_OPTIONS, 
-                      [200000, 300000, 600000, 1536000, 5000000, 6000000, 7000000, 8000000])
 
+    def _add_specs(self) -> None:
+        self.add_spec(SpecName.SAMPLE_RATE_LOWER_BOUND, 200e3)
+        self.add_spec(SpecName.SAMPLE_RATE_UPPER_BOUND, 10e6)
+        self.add_spec(SpecName.FREQUENCY_LOWER_BOUND, 1e3)
+        self.add_spec(SpecName.FREQUENCY_UPPER_BOUND, 2e9)
+        self.add_spec(SpecName.IF_GAIN_UPPER_BOUND, -20)
+        self.add_spec(SpecName.RF_GAIN_UPPER_BOUND, 0)
+        self.add_spec(SpecName.API_RETUNING_LATENCY, 25 * 1e-3)
+        self.add_spec(
+            SpecName.BANDWIDTH_OPTIONS,
+            [200000, 300000, 600000, 1536000, 5000000, 6000000, 7000000, 8000000],
+        )
+
+    def _add_capture_methods(self) -> None:
+        self.add_capture_method(
+            Mode.FIXED_CENTER_FREQUENCY, CaptureMethod.fixed_center_frequency
+        )
+        self.add_capture_method(
+            Mode.SWEPT_CENTER_FREQUENCY, CaptureMethod.swept_center_frequency
+        )
 
-    def _add_capture_methods(
-        self
-    ) -> None:
-        self.add_capture_method(Mode.FIXED_CENTER_FREQUENCY, 
-                                CaptureMethod.fixed_center_frequency)
-        self.add_capture_method(Mode.SWEPT_CENTER_FREQUENCY,
-                                CaptureMethod.swept_center_frequency)
-    
+    def _add_capture_templates(self) -> None:
+        self.add_capture_template(
+            Mode.FIXED_CENTER_FREQUENCY,
+            get_capture_template_fixed_center_frequency(self),
+        )
+        self.add_capture_template(
+            Mode.SWEPT_CENTER_FREQUENCY,
+            get_capture_template_swept_center_frequency(self),
+        )
 
-    def _add_capture_templates(
-        self
-    ) -> None:
-        self.add_capture_template(Mode.FIXED_CENTER_FREQUENCY,
-                                  get_capture_template_fixed_center_frequency(self))
-        self.add_capture_template(Mode.SWEPT_CENTER_FREQUENCY,
-                                  get_capture_template_swept_center_frequency(self))
-        
-    
-    def _add_pvalidators(
-        self
-    ) -> None:
-        self.add_pvalidator(Mode.FIXED_CENTER_FREQUENCY,
-                            get_pvalidator_fixed_center_frequency(self))
-        self.add_pvalidator(Mode.SWEPT_CENTER_FREQUENCY,
-                            get_pvalidator_swept_center_frequency(self))
+    def _add_pvalidators(self) -> None:
+        self.add_pvalidator(
+            Mode.FIXED_CENTER_FREQUENCY, get_pvalidator_fixed_center_frequency(self)
+        )
+        self.add_pvalidator(
+            Mode.SWEPT_CENTER_FREQUENCY, get_pvalidator_swept_center_frequency(self)
+        )

spectre_core/receivers/plugins/_rspduo.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# SPDX-FileCopyrightText: © 2024-2025 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
 # This file is part of SPECTRE
 # SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -8,8 +8,10 @@ from ._receiver_names import ReceiverName
 from .gr._rspduo import CaptureMethod
 from .._spec_names import SpecName
 from ._sdrplay_receiver import (
-    get_pvalidator_fixed_center_frequency, get_pvalidator_swept_center_frequency,
-    get_capture_template_fixed_center_frequency, get_capture_template_swept_center_frequency
+    get_pvalidator_fixed_center_frequency,
+    get_pvalidator_swept_center_frequency,
+    get_capture_template_fixed_center_frequency,
+    get_capture_template_swept_center_frequency,
 )
 from .._base import BaseReceiver
 from .._register import register_receiver
@@ -18,54 +20,67 @@ from .._register import register_receiver
 @dataclass
 class Mode:
     """An operating mode for the `RSPduo` receiver."""
-    TUNER_1_FIXED_CENTER_FREQUENCY  = f"tuner_1_fixed_center_frequency"
-    TUNER_2_FIXED_CENTER_FREQUENCY  = f"tuner_2_fixed_center_frequency"
-    TUNER_1_SWEPT_CENTER_FREQUENCY  = f"tuner_1_swept_center_frequency"
+
+    TUNER_1_FIXED_CENTER_FREQUENCY = f"tuner_1_fixed_center_frequency"
+    TUNER_2_FIXED_CENTER_FREQUENCY = f"tuner_2_fixed_center_frequency"
+    TUNER_1_SWEPT_CENTER_FREQUENCY = f"tuner_1_swept_center_frequency"
 
 
 @register_receiver(ReceiverName.RSPDUO)
 class RSPduo(BaseReceiver):
     """Receiver implementation for the SDRPlay RSPduo (https://www.sdrplay.com/rspduo/)"""
+
     def _add_specs(self) -> None:
-        self.add_spec( SpecName.SAMPLE_RATE_LOWER_BOUND, 200e3     )
-        self.add_spec( SpecName.SAMPLE_RATE_UPPER_BOUND, 10e6      )
-        self.add_spec( SpecName.FREQUENCY_LOWER_BOUND  , 1e3       )
-        self.add_spec( SpecName.FREQUENCY_UPPER_BOUND  , 2e9       )
-        self.add_spec( SpecName.IF_GAIN_UPPER_BOUND    , -20       )
-        self.add_spec( SpecName.RF_GAIN_UPPER_BOUND    , 0         )
-        self.add_spec( SpecName.API_RETUNING_LATENCY   , 50 * 1e-3 )
-        self.add_spec( SpecName.BANDWIDTH_OPTIONS, 
-                      [200000, 300000, 600000, 1536000, 5000000, 6000000, 7000000, 8000000])
+        self.add_spec(SpecName.SAMPLE_RATE_LOWER_BOUND, 200e3)
+        self.add_spec(SpecName.SAMPLE_RATE_UPPER_BOUND, 10e6)
+        self.add_spec(SpecName.FREQUENCY_LOWER_BOUND, 1e3)
+        self.add_spec(SpecName.FREQUENCY_UPPER_BOUND, 2e9)
+        self.add_spec(SpecName.IF_GAIN_UPPER_BOUND, -20)
+        self.add_spec(SpecName.RF_GAIN_UPPER_BOUND, 0)
+        self.add_spec(SpecName.API_RETUNING_LATENCY, 50 * 1e-3)
+        self.add_spec(
+            SpecName.BANDWIDTH_OPTIONS,
+            [200000, 300000, 600000, 1536000, 5000000, 6000000, 7000000, 8000000],
+        )
 
+    def _add_capture_methods(self) -> None:
+        self.add_capture_method(
+            Mode.TUNER_1_FIXED_CENTER_FREQUENCY,
+            CaptureMethod.tuner_1_fixed_center_frequency,
+        )
+        self.add_capture_method(
+            Mode.TUNER_2_FIXED_CENTER_FREQUENCY,
+            CaptureMethod.tuner_2_fixed_center_frequency,
+        )
+        self.add_capture_method(
+            Mode.TUNER_1_SWEPT_CENTER_FREQUENCY,
+            CaptureMethod.tuner_1_swept_center_frequency,
+        )
 
-    def _add_capture_methods(
-        self
-    ) -> None:
-        self.add_capture_method(Mode.TUNER_1_FIXED_CENTER_FREQUENCY, 
-                                CaptureMethod.tuner_1_fixed_center_frequency)
-        self.add_capture_method(Mode.TUNER_2_FIXED_CENTER_FREQUENCY, 
-                                CaptureMethod.tuner_2_fixed_center_frequency)
-        self.add_capture_method(Mode.TUNER_1_SWEPT_CENTER_FREQUENCY, 
-                                CaptureMethod.tuner_1_swept_center_frequency)
-    
+    def _add_capture_templates(self) -> None:
+        self.add_capture_template(
+            Mode.TUNER_1_FIXED_CENTER_FREQUENCY,
+            get_capture_template_fixed_center_frequency(self),
+        )
+        self.add_capture_template(
+            Mode.TUNER_2_FIXED_CENTER_FREQUENCY,
+            get_capture_template_fixed_center_frequency(self),
+        )
+        self.add_capture_template(
+            Mode.TUNER_1_SWEPT_CENTER_FREQUENCY,
+            get_capture_template_swept_center_frequency(self),
+        )
 
-    def _add_capture_templates(
-        self
-    ) -> None:
-        self.add_capture_template(Mode.TUNER_1_FIXED_CENTER_FREQUENCY,
-                                  get_capture_template_fixed_center_frequency(self))
-        self.add_capture_template(Mode.TUNER_2_FIXED_CENTER_FREQUENCY,
-                                  get_capture_template_fixed_center_frequency(self))
-        self.add_capture_template(Mode.TUNER_1_SWEPT_CENTER_FREQUENCY,
-                                  get_capture_template_swept_center_frequency(self))
-        
-    
-    def _add_pvalidators(
-        self
-    ) -> None:
-        self.add_pvalidator(Mode.TUNER_1_FIXED_CENTER_FREQUENCY,
-                            get_pvalidator_fixed_center_frequency(self))
-        self.add_pvalidator(Mode.TUNER_2_FIXED_CENTER_FREQUENCY,
-                            get_pvalidator_fixed_center_frequency(self))
-        self.add_pvalidator(Mode.TUNER_1_SWEPT_CENTER_FREQUENCY,
-                            get_pvalidator_swept_center_frequency(self))
+    def _add_pvalidators(self) -> None:
+        self.add_pvalidator(
+            Mode.TUNER_1_FIXED_CENTER_FREQUENCY,
+            get_pvalidator_fixed_center_frequency(self),
+        )
+        self.add_pvalidator(
+            Mode.TUNER_2_FIXED_CENTER_FREQUENCY,
+            get_pvalidator_fixed_center_frequency(self),
+        )
+        self.add_pvalidator(
+            Mode.TUNER_1_SWEPT_CENTER_FREQUENCY,
+            get_pvalidator_swept_center_frequency(self),
+        )

spectre_core/receivers/plugins/_sdrplay_receiver.py

@@ -1,174 +1,158 @@
-# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# SPDX-FileCopyrightText: © 2024-2025 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
 # This file is part of SPECTRE
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 from typing import Callable, overload
 
 from spectre_core.capture_configs import (
-    CaptureTemplate, CaptureMode, Parameters, Bound, PName,
-    get_base_capture_template, get_base_ptemplate, OneOf,
-    validate_fixed_center_frequency, validate_swept_center_frequency
+    CaptureTemplate,
+    CaptureMode,
+    Parameters,
+    Bound,
+    PName,
+    get_base_capture_template,
+    get_base_ptemplate,
+    OneOf,
+    validate_fixed_center_frequency,
+    validate_swept_center_frequency,
 )
 from .._base import BaseReceiver
 from .._spec_names import SpecName
 
 
 def get_pvalidator_fixed_center_frequency(
-    sdrplay_receiver: BaseReceiver 
+    sdrplay_receiver: BaseReceiver,
 ) -> Callable[[Parameters], None]:
     def pvalidator(parameters: Parameters) -> None:
         validate_fixed_center_frequency(parameters)
+
     return pvalidator
 
 
 def get_pvalidator_swept_center_frequency(
-    sdrplay_receiver: BaseReceiver 
+    sdrplay_receiver: BaseReceiver,
 ) -> Callable[[Parameters], None]:
     def pvalidator(parameters: Parameters) -> None:
-        validate_swept_center_frequency(parameters,
-                                        sdrplay_receiver.get_spec(SpecName.API_RETUNING_LATENCY))
+        validate_swept_center_frequency(
+            parameters, sdrplay_receiver.get_spec(SpecName.API_RETUNING_LATENCY)
+        )
+
     return pvalidator
 
 
 def get_capture_template_fixed_center_frequency(
-    sdrplay_receiver: BaseReceiver
+    sdrplay_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.IF_GAIN) )
-    capture_template.add_ptemplate( get_base_ptemplate(PName.RF_GAIN) )
+
+    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.IF_GAIN))
+    capture_template.add_ptemplate(get_base_ptemplate(PName.RF_GAIN))
 
     capture_template.set_defaults(
-        (PName.BATCH_SIZE,            3.0),
-        (PName.CENTER_FREQUENCY,      95800000),
-        (PName.SAMPLE_RATE,           600000),
-        (PName.BANDWIDTH,             600000),
-        (PName.WINDOW_HOP,            512),
-        (PName.WINDOW_SIZE,           1024),
-        (PName.WINDOW_TYPE,           "blackman"),
-        (PName.RF_GAIN,               -30),
-        (PName.IF_GAIN,               -30)
-    )   
+        (PName.BATCH_SIZE, 3.0),
+        (PName.CENTER_FREQUENCY, 95800000),
+        (PName.SAMPLE_RATE, 600000),
+        (PName.BANDWIDTH, 600000),
+        (PName.WINDOW_HOP, 512),
+        (PName.WINDOW_SIZE, 1024),
+        (PName.WINDOW_TYPE, "blackman"),
+        (PName.RF_GAIN, -30),
+        (PName.IF_GAIN, -30),
+    )
 
     capture_template.add_pconstraint(
         PName.CENTER_FREQUENCY,
         [
             Bound(
                 lower_bound=sdrplay_receiver.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
-                upper_bound=sdrplay_receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND)
+                upper_bound=sdrplay_receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND),
             )
-        ]
+        ],
     )
     capture_template.add_pconstraint(
         PName.SAMPLE_RATE,
         [
             Bound(
                 lower_bound=sdrplay_receiver.get_spec(SpecName.SAMPLE_RATE_LOWER_BOUND),
-                upper_bound=sdrplay_receiver.get_spec(SpecName.SAMPLE_RATE_UPPER_BOUND)
+                upper_bound=sdrplay_receiver.get_spec(SpecName.SAMPLE_RATE_UPPER_BOUND),
             )
-        ]
+        ],
     )
     capture_template.add_pconstraint(
-        PName.BANDWIDTH,
-        [
-            OneOf(
-                sdrplay_receiver.get_spec( SpecName.BANDWIDTH_OPTIONS )
-            )
-        ]
+        PName.BANDWIDTH, [OneOf(sdrplay_receiver.get_spec(SpecName.BANDWIDTH_OPTIONS))]
     )
     capture_template.add_pconstraint(
         PName.IF_GAIN,
-        [
-            Bound(
-                upper_bound=sdrplay_receiver.get_spec(SpecName.IF_GAIN_UPPER_BOUND)
-            )
-        ]
+        [Bound(upper_bound=sdrplay_receiver.get_spec(SpecName.IF_GAIN_UPPER_BOUND))],
     )
     capture_template.add_pconstraint(
         PName.RF_GAIN,
-        [
-            Bound(
-                upper_bound=sdrplay_receiver.get_spec(SpecName.RF_GAIN_UPPER_BOUND)
-            )
-        ]
+        [Bound(upper_bound=sdrplay_receiver.get_spec(SpecName.RF_GAIN_UPPER_BOUND))],
     )
     return capture_template
 
 
 def get_capture_template_swept_center_frequency(
-    sdrplay_receiver: BaseReceiver
+    sdrplay_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.IF_GAIN) )
-    capture_template.add_ptemplate( get_base_ptemplate(PName.RF_GAIN) )
+    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.IF_GAIN))
+    capture_template.add_ptemplate(get_base_ptemplate(PName.RF_GAIN))
 
     capture_template.set_defaults(
-        (PName.BATCH_SIZE,            4.0),
-        (PName.MIN_FREQUENCY,         95000000),
-        (PName.MAX_FREQUENCY,         100000000),
-        (PName.SAMPLES_PER_STEP,      80000),
-        (PName.FREQUENCY_STEP,        1536000),
-        (PName.SAMPLE_RATE,           1536000),
-        (PName.BANDWIDTH,             1536000),
-        (PName.WINDOW_HOP,            512),
-        (PName.WINDOW_SIZE,           1024),
-        (PName.WINDOW_TYPE,           "blackman"),
-        (PName.RF_GAIN,               -30),
-        (PName.IF_GAIN,               -30)
-    )   
+        (PName.BATCH_SIZE, 4.0),
+        (PName.MIN_FREQUENCY, 95000000),
+        (PName.MAX_FREQUENCY, 100000000),
+        (PName.SAMPLES_PER_STEP, 80000),
+        (PName.FREQUENCY_STEP, 1536000),
+        (PName.SAMPLE_RATE, 1536000),
+        (PName.BANDWIDTH, 1536000),
+        (PName.WINDOW_HOP, 512),
+        (PName.WINDOW_SIZE, 1024),
+        (PName.WINDOW_TYPE, "blackman"),
+        (PName.RF_GAIN, -30),
+        (PName.IF_GAIN, -30),
+    )
 
     capture_template.add_pconstraint(
         PName.MIN_FREQUENCY,
         [
             Bound(
                 lower_bound=sdrplay_receiver.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
-                upper_bound=sdrplay_receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND)
+                upper_bound=sdrplay_receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND),
             )
-        ]
+        ],
     )
     capture_template.add_pconstraint(
         PName.MAX_FREQUENCY,
         [
             Bound(
                 lower_bound=sdrplay_receiver.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
-                upper_bound=sdrplay_receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND)
+                upper_bound=sdrplay_receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND),
             )
-        ]
+        ],
     )
     capture_template.add_pconstraint(
         PName.SAMPLE_RATE,
         [
             Bound(
                 lower_bound=sdrplay_receiver.get_spec(SpecName.SAMPLE_RATE_LOWER_BOUND),
-                upper_bound=sdrplay_receiver.get_spec(SpecName.SAMPLE_RATE_UPPER_BOUND)
+                upper_bound=sdrplay_receiver.get_spec(SpecName.SAMPLE_RATE_UPPER_BOUND),
             )
-        ]
+        ],
     )
     capture_template.add_pconstraint(
-        PName.BANDWIDTH,
-        [
-            OneOf(
-                sdrplay_receiver.get_spec( SpecName.BANDWIDTH_OPTIONS )
-            )
-        ]
+        PName.BANDWIDTH, [OneOf(sdrplay_receiver.get_spec(SpecName.BANDWIDTH_OPTIONS))]
     )
     capture_template.add_pconstraint(
         PName.IF_GAIN,
-        [
-            Bound(
-                upper_bound=sdrplay_receiver.get_spec(SpecName.IF_GAIN_UPPER_BOUND)
-            )
-        ]
+        [Bound(upper_bound=sdrplay_receiver.get_spec(SpecName.IF_GAIN_UPPER_BOUND))],
     )
     capture_template.add_pconstraint(
         PName.RF_GAIN,
-        [
-            Bound(
-                upper_bound=sdrplay_receiver.get_spec(SpecName.RF_GAIN_UPPER_BOUND)
-            )
-        ]
+        [Bound(upper_bound=sdrplay_receiver.get_spec(SpecName.RF_GAIN_UPPER_BOUND))],
     )
     return capture_template