python-aaronia 0.5.0__tar.gz → 0.5.1__tar.gz

{python_aaronia-0.5.0 → python_aaronia-0.5.1}/CHANGELOG.md

@@ -2,6 +2,38 @@
 
 All notable changes to this project will be documented in this file.
 
+## [Unreleased]
+
+## [v0.5.1] - 2026-08-11
+
+### Fixed
+- **Mid-stream HTTP retuning was silently broken on real hardware.**
+  Live testing against RTSA-Suite PRO (SPECTRAN V6 ECO) showed the
+  `/control` capture endpoint applies a frequency change only when
+  `frequencyCenter` and `frequencySpan` are both present; a lone
+  frequency field returns `{"success":true}` but is ignored, so
+  `set_center_frequency` / `set_span_frequency` (and therefore hop-mode
+  retuning and the SoapySDR/seify/Python retune surfaces over HTTP)
+  reported success while the device kept streaming at the old tuning.
+  All HTTP retune paths now send the complete capture tuple (center,
+  span, reference level), `configure_capture` warns on lone-frequency
+  payloads, and a live smoke test (`live_retune_full_tuple_applies`)
+  plus a span-required mock predicate guard the regression.
+  `referenceLevel`-only PUTs were unaffected (they apply on their own).
+- Corrected the docs that mis-attributed the silent-ignore behavior to
+  the Aaronia "Remote Config" license (READMEs, DESIGN.md, HTTPSPEC.md,
+  `probe_remote_config_license` doc comments): retuning goes through the
+  license-free `/control` endpoint; the license gates only
+  `/remoteconfig` writes.
+
+### CI
+- Clippy now runs with `--workspace` (CI, `scripts/ci-local.sh`, and the
+  Linux-VM leg): `python-aaronia` is a workspace member that no job
+  linted, and it had accumulated 12 unflagged clippy errors — a genuine
+  `type_complexity` (fixed with a type alias) and 11 `useless_conversion`
+  reports from pyo3 0.22's `#[pymethods]` wrapper codegen (crate-level
+  allow, documented for removal at pyo3 ≥ 0.23).
+
 ## [v0.5.0] - 2026-08-11
 
 Breaking 0.x release combining the RTSA file-format verification work

{python_aaronia-0.5.0 → python_aaronia-0.5.1}/CONTRIBUTING.md

@@ -13,7 +13,7 @@ cd sdr-aaronia-rs
 # Run the standard validation suite
 cargo test                                        # unit + integration + properties (default features)
 cargo test --test spec_coverage -- --nocapture    # spec inventory report
-cargo clippy --all-features --all-targets -- -D warnings
+cargo clippy --workspace --all-features --all-targets -- -D warnings
 cargo fmt --all --check
 ```
 

{python_aaronia-0.5.0 → python_aaronia-0.5.1}/Cargo.lock

@@ -3057,7 +3057,7 @@ dependencies = [
 
 [[package]]
 name = "python-aaronia"
-version = "0.5.0"
+version = "0.5.1"
 dependencies = [
  "arrow",
  "num-complex",
@@ -3592,7 +3592,7 @@ checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
 [[package]]
 name = "sdr-aaronia-rs"
-version = "0.5.0"
+version = "0.5.1"
 dependencies = [
  "anyhow",
  "bitflags 2.13.0",

{python_aaronia-0.5.0 → python_aaronia-0.5.1}/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "sdr-aaronia-rs"
-description = "Unified Rust interface for Aaronia Spectran V6 SDRs: native RTSA SDK, HTTP streaming, and RTSA capture-file sources"
+description = "Unified Rust interface for Aaronia Spectran Spectrum Analyzers / SDRs, featuring Python bindings, a SoapySDR plugin, HTTP streaming, and native SDK support."
 license = "GPL-3.0-or-later"
-version = "0.5.0"
+version = "0.5.1"
 edition = "2024"
 repository = "https://github.com/isaacbentley/sdr-aaronia-rs"
 readme = "README.md"

{python_aaronia-0.5.0 → python_aaronia-0.5.1}/DESIGN.md

@@ -72,7 +72,7 @@ Available on Windows and Linux only, behind the non-default `native-sdk` feature
 Under the `sdr-source` feature, `AaroniaSdrSource` (in `sdr_source_impl.rs`) implements the `SdrSource` trait from the external `orecchiette-sdr-source-rs` crate, which the crate re-exports as `sdr_source`. Automatic mid-stream retuning via `SourceConfig.channels_hz` is supported per backend:
 
 - **Native SDK**: re-issues `configure_iq_receiver` with the new center frequency, applying the change to the open device handle via the `main/centerfreq` configuration key. No stream restart is required.
-- **HTTP**: `AaroniaSource::set_center_frequency` wraps `HttpEndpointsClient::configure_capture(frequency_center=...)` as a `PUT` to the license-free `/control` endpoint. The RTSA-Suite "Remote Config" license gates the separate `/remoteconfig` write path, which the hopping code deliberately avoids — hopping is not gated on the license probe.
+- **HTTP**: `AaroniaSource::set_center_frequency` wraps `HttpEndpointsClient::configure_capture` as a `PUT` to the license-free `/control` endpoint, always sending the complete capture tuple (center, span, reference level) with unchanged values filled from the cached config. The full tuple is required: RTSA servers silently ignore a capture `PUT` carrying only one of the two frequency fields (it returns `{"success":true}` but the device stays put — live-verified). The RTSA-Suite "Remote Config" license gates the separate `/remoteconfig` write path, which the hopping code deliberately avoids — hopping is not gated on the license probe.
 - **File**: not supported.
 
 Hop dwell deadlines come from `sdr_source::DwellController`; per-hop pacing additionally inserts a ~75 ms settle after every retune (`RETUNE_SETTLE` in `sdr_source_impl.rs`) to ride out the RTSA's apply-config latency and flush stale samples from the pipeline.

{python_aaronia-0.5.0 → python_aaronia-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aaronia
-Version: 0.5.0
+Version: 0.5.1
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)

{python_aaronia-0.5.0 → python_aaronia-0.5.1}/README.md

@@ -5,7 +5,7 @@
 [![CI](https://github.com/isaacbentley/sdr-aaronia-rs/actions/workflows/ci.yml/badge.svg)](https://github.com/isaacbentley/sdr-aaronia-rs/actions/workflows/ci.yml)
 [![License: GPL-3.0-or-later](https://img.shields.io/github/license/isaacbentley/sdr-aaronia-rs.svg)](https://choosealicense.com/licenses/gpl-3.0/)
 
-A Rust library for interfacing with Aaronia Spectran SDR devices.
+Unified Rust interface for Aaronia Spectran Spectrum Analyzers / SDRs, featuring Python bindings, a SoapySDR plugin, HTTP streaming, and native SDK support.
 
 *Disclaimer: This project is not affiliated with Aaronia AG. Aaronia, SPECTRAN, and RTSA-Suite PRO are trademarks of Aaronia AG.*
 
@@ -33,7 +33,7 @@ Interfacing with SDR hardware typically requires choosing between proprietary na
 - **Python Data-Science Native:** PyO3 bindings with single-copy reads into NumPy arrays and Apache Arrow buffers (one copy out of the Rust receive buffer per read).
 - **SDR Ecosystem Plugins:** a C++ `SoapySDR` plugin and a Rust-native `seify` backend.
 
-*Note: writes to the HTTP `/remoteconfig` endpoint require a separate Aaronia "Remote Config" license; capture control via `/control` (including retuning) does not.*
+*Note: writes to the HTTP `/remoteconfig` endpoint require a separate Aaronia "Remote Config" license; capture control via `/control` (including retuning) does not. One server quirk to know: `/control` applies a frequency change only when `frequencyCenter` **and** `frequencySpan` are both present — a lone frequency field returns `{"success":true}` but is silently ignored. The crate always sends the complete tuple.*
 
 ## Installation
 

{python_aaronia-0.5.0 → python_aaronia-0.5.1}/docs/HTTPSPEC.md

@@ -283,6 +283,16 @@ packet-metadata object, so `payload`, `minPower`, `maxPower`, and
 }
 ```
 
+> **Both frequency fields are required for a retune to apply.** Live
+> testing against RTSA-Suite PRO (HTTP server block fed by a SPECTRAN
+> V6 ECO) shows the server returns `{"success":true}` for a capture
+> `PUT` carrying only `frequencyCenter` or only `frequencySpan` but
+> silently ignores it — the device keeps streaming at its previous
+> tuning. Sending `frequencyCenter` **and** `frequencySpan` together
+> applies reliably. `referenceLevel` on its own does apply. No license
+> is involved: `/control` capture writes work without the Remote
+> Config license.
+
 #### Start/Stop Antenna Autorotation
 ```json
 {
@@ -554,7 +564,7 @@ Data captured using antennas with location or directional information.
 The client therefore exposes two methods:
 
 - `detect_remote_config_license()` — **read-only**. Never touches device state. Classifies 401/403 responses; on read success it returns `Unknown` (write capability unproven).
-- `probe_remote_config_write_license()` — **active probe**. Performs a read-modify-restore cycle on `reflevel` (+1 dB, restored best-effort) to positively verify write capability. Use only when you need proof — e.g. before frequency hopping, where an unlicensed retune silently no-ops server-side.
+- `probe_remote_config_write_license()` — **active probe**. Performs a read-modify-restore cycle on `reflevel` (+1 dB, restored best-effort) to positively verify write capability. Use only when you genuinely need proof of `/remoteconfig` write access. Frequency hopping does **not** need it — retuning goes through the license-free `/control` endpoint (see the capture-control note above; the silent-ignore behavior once attributed to licensing was traced to partial capture payloads).
 
 **Practical Detection (Active Probe)**:
 ```rust

{python_aaronia-0.5.0 → python_aaronia-0.5.1}/python-aaronia/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "python-aaronia"
-version = "0.5.0"
+version = "0.5.1"
 edition = "2024"
 description = "Python bindings for sdr-aaronia-rs (Aaronia SPECTRAN V6 SDR source)"
 license = "GPL-3.0-or-later"

{python_aaronia-0.5.0 → python_aaronia-0.5.1}/python-aaronia/src/lib.rs

@@ -13,11 +13,16 @@
 //! timeout, shutdown) releases the GIL, so other Python threads keep
 //! running and `KeyboardInterrupt` stays deliverable between calls.
 
-// The two allows: pyo3 0.22's proc-macros expand to code that trips
-// edition-2024's unsafe_op_in_unsafe_fn and reference the `gil-refs`
-// cfg; both are fixed upstream in pyo3 0.23 — drop these when bumping.
+// These allows are all pyo3 0.22 proc-macro fallout, fixed upstream in
+// pyo3 0.23 — drop them when bumping: the expansions trip
+// edition-2024's unsafe_op_in_unsafe_fn, reference the `gil-refs` cfg,
+// and route #[pymethods] `PyResult` returns through an `.into()` in
+// generated wrapper fns that clippy ≥ 1.89 flags as useless_conversion
+// (attributed to the method signature; an impl-level allow doesn't
+// reach the wrappers, hence crate-level).
 #![allow(unsafe_op_in_unsafe_fn)]
 #![allow(unexpected_cfgs)]
+#![allow(clippy::useless_conversion)]
 
 use arrow::array::{Array, FixedSizeListArray};
 use arrow::datatypes::{DataType, Field};
@@ -244,6 +249,12 @@ impl PyAaroniaConfig {
     }
 }
 
+/// The `(rx1, rx2)` pair returned by `read_samples_dual_numpy`.
+type DualArrays<'py> = (
+    Bound<'py, PyArray1<Complex32>>,
+    Bound<'py, PyArray1<Complex32>>,
+);
+
 /// A streaming IQ source. Construct, `start_streaming(config)`, then
 /// call the `read_samples_*` methods; each blocks (GIL released) until
 /// `count` samples arrive or the internal 30-second timeout raises
@@ -404,10 +415,7 @@ impl PyAaroniaSource {
         &mut self,
         py: Python<'py>,
         count: usize,
-    ) -> PyResult<(
-        Bound<'py, PyArray1<Complex32>>,
-        Bound<'py, PyArray1<Complex32>>,
-    )> {
+    ) -> PyResult<DualArrays<'py>> {
         if count > MAX_READ_SAMPLES {
             return Err(PyValueError::new_err(format!(
                 "count {count} exceeds the per-read limit of {MAX_READ_SAMPLES} samples"

{python_aaronia-0.5.0 → python_aaronia-0.5.1}/scripts/ci-local.sh

@@ -73,8 +73,9 @@ if ! skipped fmt; then
 fi
 
 if ! skipped clippy; then
-    step "cargo clippy --all-features --all-targets -- -D warnings"
-    cargo clippy --all-features --all-targets -- -D warnings
+    # --workspace pulls in python-aaronia, which no other step lints.
+    step "cargo clippy --workspace --all-features --all-targets -- -D warnings"
+    cargo clippy --workspace --all-features --all-targets -- -D warnings
 fi
 
 if ! skipped test; then
@@ -139,7 +140,7 @@ fi
 # (~/Documents ⇒ EDEADLK), hence the rsync to /private/tmp first.
 if ! skipped vm; then
     if container system status >/dev/null 2>&1; then
-        step "CI ubuntu leg in Linux VM: clippy --all-features --all-targets + cargo test --all-features"
+        step "CI ubuntu leg in Linux VM: clippy --workspace --all-features --all-targets + cargo test --all-features"
         # Dedicated directory: nothing else may write here (a shared
         # scratch copy once had another tool rsync over it mid-run).
         vm_dir=/private/tmp/aaronia-ci-vm
@@ -149,17 +150,22 @@ if ! skipped vm; then
         # stale call signature shipped red to CI past a --lib-only VM
         # run. This mirrors CI's ubuntu leg command-for-command.
         # rust:slim lacks what the GitHub ubuntu runner image ships
-        # preinstalled: clippy, pkg-config, and ALSA headers (futuresdr's
-        # audio feature -> alsa-sys). Install per run; the persistent
-        # target/ under $vm_dir keeps rebuilds incremental.
+        # preinstalled: clippy, pkg-config, ALSA headers (futuresdr's
+        # audio feature -> alsa-sys), and python3 (pyo3's build script
+        # needs an interpreter for the --workspace clippy leg). Install
+        # per run; the persistent target/ under $vm_dir keeps rebuilds
+        # incremental.
         # --memory 8g: the all-features lib-test link OOM-kills the
         # container CLI's default allocation (ld dies with SIGKILL).
+        # clippy is --workspace (mirrors CI); test stays root-crate —
+        # python-aaronia's Python-side behavior is covered by the
+        # python step below and CI's maturin+pytest job.
         container run --rm --memory 8g --cpus 4 \
             -v "$vm_dir":/w -w /w -e PROPTEST_CASES="$PROPTEST_CASES" rust:slim \
             sh -c 'rustup component add clippy >/dev/null 2>&1; \
                    apt-get update -qq >/dev/null && \
-                   apt-get install -y -qq pkg-config libasound2-dev >/dev/null; \
-                   cargo clippy --all-features --all-targets -- -D warnings \
+                   apt-get install -y -qq pkg-config libasound2-dev python3 >/dev/null; \
+                   cargo clippy --workspace --all-features --all-targets -- -D warnings \
                    && cargo test --all-features'
     else
         echo "vm step: 'container system start' not running — skipping" \

{python_aaronia-0.5.0 → python_aaronia-0.5.1}/soapy-aaronia/README.md

@@ -57,7 +57,11 @@ sdr = SoapySDR.Device("driver=aaronia,url=http://atc.local:54664,format=I16")
   device arg changes what crosses the network.
 - `readStream` honours `timeoutUs` and returns partial reads within the
   deadline, per the SoapySDR contract. Retuning while streaming is safe
-  (fully serialized against the reader).
+  (fully serialized against the reader) and needs no Aaronia license:
+  the plugin retunes through the RTSA `/control` endpoint, always
+  sending center frequency and span together — RTSA servers silently
+  ignore capture requests that carry only one of the two (live-verified
+  against RTSA-Suite PRO with a SPECTRAN V6 ECO).
 - **TX:** `CF32`, single channel, available only when the module is
   built against the native SDK on Windows/Linux — elsewhere
   `setupStream(TX)` fails with a descriptive error. Bursts are pushed
@@ -78,8 +82,5 @@ sdr = SoapySDR.Device("driver=aaronia,url=http://atc.local:54664,format=I16")
 - One RX channel through the plugin (`rx_channel=Rx2` selects the second
   antenna input; true dual-channel reads are available via the crate's
   Rust/Python/C APIs, not the Soapy streaming interface).
-- Without Aaronia's Remote Config license, the RTSA server accepts
-  retune requests over HTTP but may silently ignore them — the device
-  keeps streaming at the mission's configured frequency.
 - Enumeration advertises a default localhost candidate without probing
   it (`find()` must not block on the network).

{python_aaronia-0.5.0 → python_aaronia-0.5.1}/src/http_endpoints.rs

@@ -917,7 +917,27 @@ impl HttpEndpointsClient {
     }
 
     /// Configures capture parameters via the `/control` endpoint.
+    ///
+    /// **Frequency changes need `frequencyCenter` and `frequencySpan`
+    /// together.** RTSA servers return `{"success":true}` for a capture
+    /// `PUT` that carries only one of the two frequency fields but
+    /// silently ignore it; the retune applies only when both are present
+    /// (verified live against RTSA-Suite PRO driving a SPECTRAN V6 ECO —
+    /// center-only and span-only PUTs each no-opped, center+span
+    /// applied). `referenceLevel` does apply on its own. A lone frequency
+    /// field logs a warning here and is still sent, since other server
+    /// versions may accept it.
     pub async fn configure_capture(&self, config: CaptureControl) -> Result<()> {
+        let has_range = config.frequency_start.is_some() && config.frequency_end.is_some();
+        if !has_range && (config.frequency_center.is_some() != config.frequency_span.is_some()) {
+            warn!(
+                "Partial capture PUT ({:?}): RTSA servers are known to accept a lone \
+                 frequencyCenter/frequencySpan with success=true but silently ignore it; \
+                 include both fields for the retune to apply",
+                config
+            );
+        }
+
         let url = format!("{}/control", self.base_url);
         let request = self.control_request(self.client.put(&url)).json(&config);
         Self::ensure_success("Capture configuration", request.send().await?)?;
@@ -1060,9 +1080,12 @@ impl HttpEndpointsClient {
     /// `reflevel` parameter by +1 dB and restores it best-effort. If the
     /// restore fails (network drop mid-probe), the device is left with the
     /// adjusted reference level. Only call this when you genuinely need
-    /// proof of write capability — e.g. before frequency-hopping, where an
-    /// unlicensed `configure_capture` silently no-ops server-side and
-    /// mis-tags every downstream packet.
+    /// proof of `/remoteconfig` write capability. Note that retuning does
+    /// **not** — [`Self::configure_capture`] goes through the license-free
+    /// `/control` endpoint. (An earlier revision justified this probe by
+    /// claiming unlicensed `configure_capture` calls silently no-op; live
+    /// testing traced that behavior to partial capture payloads, not
+    /// licensing.)
     ///
     /// # Returns
     /// - `RemoteConfigStatus::Active` - License is active, write operations work

{python_aaronia-0.5.0 → python_aaronia-0.5.1}/src/unified_source.rs

@@ -1012,11 +1012,20 @@ impl AaroniaSource {
 
     /// Retune the source to a new centre frequency without rebuilding it.
     ///
-    /// - **HTTP**: wraps `HttpEndpointsClient::configure_capture(frequency_center=freq)`,
-    ///   a `PUT` to the license-free `/control` endpoint. The RTSA-Suite
-    ///   "Remote Config" license gates the `/remoteconfig` write path, not
-    ///   this one; callers that need a `/remoteconfig` write-license check
-    ///   should call [`Self::probe_remote_config_license`] separately.
+    /// - **HTTP**: wraps `HttpEndpointsClient::configure_capture`, a `PUT`
+    ///   to the license-free `/control` endpoint, always sending the
+    ///   complete capture tuple (centre, span, reference level) with the
+    ///   unchanged values taken from the cached config. The full tuple is
+    ///   load-bearing: RTSA servers return `{"success":true}` for a
+    ///   capture `PUT` that carries only one of the two frequency fields
+    ///   but silently ignore it — the retune applies only when
+    ///   `frequencyCenter` and `frequencySpan` are both present (verified
+    ///   live against RTSA-Suite PRO driving a SPECTRAN V6 ECO; the
+    ///   reference level, by contrast, does apply on its own). The
+    ///   RTSA-Suite "Remote Config" license gates
+    ///   the `/remoteconfig` write path, not this one; callers that need
+    ///   a `/remoteconfig` write-license check should call
+    ///   [`Self::probe_remote_config_license`] separately.
     /// - **Native SDK**: re-issues `configure_iq_receiver` with the new
     ///   centre frequency, the existing span, and the existing reference
     ///   level. The SDK config system applies the change to the open device
@@ -1059,9 +1068,14 @@ impl AaroniaSource {
                     .http_client
                     .as_ref()
                     .ok_or_else(|| Error::Config("HTTP client not initialized".to_string()))?;
+                // Full tuple, not just the changed field: the server
+                // ignores capture PUTs that lack frequencySpan (see the
+                // doc comment above).
                 client
                     .configure_capture(crate::http_endpoints::CaptureControl {
                         frequency_center: Some(freq),
+                        frequency_span: Some(self.config.span_frequency),
+                        reference_level: Some(self.config.reference_level as f32),
                         control_type: crate::http_endpoints::ControlType::Capture,
                         ..Default::default()
                     })
@@ -1118,9 +1132,13 @@ impl AaroniaSource {
                     .http_client
                     .as_ref()
                     .ok_or_else(|| Error::Config("HTTP client not initialized".to_string()))?;
+                // Full tuple: partial capture PUTs are silently ignored
+                // by the server (see `set_center_frequency`).
                 client
                     .configure_capture(crate::http_endpoints::CaptureControl {
+                        frequency_center: Some(self.config.center_frequency),
                         frequency_span: Some(span),
+                        reference_level: Some(self.config.reference_level as f32),
                         control_type: crate::http_endpoints::ControlType::Capture,
                         ..Default::default()
                     })
@@ -1171,8 +1189,12 @@ impl AaroniaSource {
                     .http_client
                     .as_ref()
                     .ok_or_else(|| Error::Config("HTTP client not initialized".to_string()))?;
+                // Full tuple: partial capture PUTs are silently ignored
+                // by the server (see `set_center_frequency`).
                 client
                     .configure_capture(crate::http_endpoints::CaptureControl {
+                        frequency_center: Some(self.config.center_frequency),
+                        frequency_span: Some(self.config.span_frequency),
                         reference_level: Some(ref_level as f32),
                         control_type: crate::http_endpoints::ControlType::Capture,
                         ..Default::default()
@@ -1189,11 +1211,13 @@ impl AaroniaSource {
 
     /// Probe the RTSA-Suite Remote Config license status, returning
     /// [`crate::http_endpoints::RemoteConfigStatus::Active`] for non-HTTP
-    /// sources (they don't need it). Hopping orchestrators should check
-    /// this before relying on mid-stream `set_center_frequency` — without
-    /// the license, `configure_capture` returns HTTP 200 OK server-side
-    /// but silently ignores the frequency change, which would otherwise
-    /// cause downstream packets to be mis-tagged with the wrong channel.
+    /// sources (they don't need it). This concerns **`/remoteconfig`
+    /// writes only** — mid-stream retuning via [`Self::set_center_frequency`]
+    /// goes through the license-free `/control` endpoint and does not
+    /// need this probe. (An earlier revision claimed unlicensed
+    /// `configure_capture` calls were silently ignored; live testing
+    /// showed the silent ignore was caused by partial capture payloads,
+    /// not licensing — see `set_center_frequency`.)
     ///
     /// **On HTTP sources this is an active probe that temporarily
     /// perturbs device state**: it adjusts the reference level by +1 dB

{python_aaronia-0.5.0 → python_aaronia-0.5.1}/tests/live_smoke.rs

@@ -13,7 +13,8 @@
 
 use futures::stream::StreamExt;
 use sdr_aaronia_rs::http_endpoints::{
-    AuthMethod, HttpEndpointsClient, InputProcessingType, StreamParams, TxSampleRequest,
+    AuthMethod, CaptureControl, ControlType, HttpEndpointsClient, InputProcessingType,
+    StreamParams, TxSampleRequest,
 };
 use sdr_aaronia_rs::http_streaming::{DropDetector, PayloadType, StreamFormat};
 use std::time::{Duration, Instant};
@@ -594,6 +595,63 @@ fn live_stream_seify() {
     streamer.deactivate_at(None).expect("deactivate");
 }
 
+/// The `/control` capture endpoint applies a frequency change only when
+/// `frequencyCenter` and `frequencySpan` travel together — a lone
+/// frequency field returns `{"success":true}` but is silently ignored
+/// (no license involved). This proves the crate's full-tuple retune path
+/// actually moves the device, then restores the original tuning.
+#[tokio::test]
+#[ignore = "requires live RTSA-Suite PRO at AARONIA_LIVE_URL / atc.local:54664"]
+async fn live_retune_full_tuple_applies() {
+    let c = client();
+
+    let before = c.get_sample(None).await.expect("/sample baseline");
+    let center0 = (before.start_frequency + before.end_frequency) / 2.0;
+    let span0 = before.end_frequency - before.start_frequency;
+    println!(
+        "baseline: center={:.3} MHz span={:.3} MHz",
+        center0 / 1e6,
+        span0 / 1e6
+    );
+
+    // Two span-widths down: unambiguous vs. the baseline, and still
+    // comfortably inside the V6 tuning range for any plausible mission.
+    let target = center0 - 2.0 * span0;
+    let retune = |center: f64| CaptureControl {
+        frequency_center: Some(center),
+        frequency_span: Some(span0),
+        control_type: ControlType::Capture,
+        ..Default::default()
+    };
+
+    c.configure_capture(retune(target))
+        .await
+        .expect("retune PUT");
+
+    let deadline = Instant::now() + Duration::from_secs(10);
+    let mut applied = false;
+    while Instant::now() < deadline {
+        let s = c.get_sample(None).await.expect("/sample poll");
+        let center = (s.start_frequency + s.end_frequency) / 2.0;
+        if (center - target).abs() < span0 / 2.0 {
+            applied = true;
+            break;
+        }
+        tokio::time::sleep(Duration::from_millis(250)).await;
+    }
+
+    // Restore before asserting so a failed assertion doesn't leave the
+    // device parked off-mission.
+    c.configure_capture(retune(center0))
+        .await
+        .expect("restore PUT");
+
+    assert!(
+        applied,
+        "full-tuple /control retune to {target} Hz never reflected in /sample"
+    );
+}
+
 // NOTE: there is intentionally no Rust-side SoapySDR live test here.
 // A `soapysdr` dev-dependency makes `cargo test` unbuildable on any
 // machine without system SoapySDR + libclang. Equivalent live coverage:

{python_aaronia-0.5.0 → python_aaronia-0.5.1}/tests/sdr_source_impl_test.rs

@@ -56,14 +56,20 @@ async fn wait_for_request(
 }
 
 /// `wait_for_request` predicate: a `/control` PUT whose JSON body retunes
-/// `frequencyCenter` to `freq` (within 1 Hz).
+/// `frequencyCenter` to `freq` (within 1 Hz) *and* carries
+/// `frequencySpan`. The span requirement is a regression guard: RTSA
+/// servers silently ignore capture PUTs with a lone frequency field, so
+/// a center-only PUT is not a retune (live-verified; see
+/// `configure_capture`).
 fn control_put_tuning_to(freq: f64) -> impl Fn(&wiremock::Request) -> bool {
     move |r: &wiremock::Request| {
         r.url.path() == "/control"
-            && r.body_json::<serde_json::Value>()
-                .ok()
-                .and_then(|v| v.get("frequencyCenter").and_then(|f| f.as_f64()))
-                .is_some_and(|f| (f - freq).abs() < 1.0)
+            && r.body_json::<serde_json::Value>().ok().is_some_and(|v| {
+                v.get("frequencySpan").and_then(|s| s.as_f64()).is_some()
+                    && v.get("frequencyCenter")
+                        .and_then(|f| f.as_f64())
+                        .is_some_and(|f| (f - freq).abs() < 1.0)
+            })
     }
 }