python-aaronia 0.7.5__tar.gz → 0.7.6__tar.gz

{python_aaronia-0.7.5 → python_aaronia-0.7.6}/CHANGELOG.md

@@ -4,6 +4,91 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [v0.7.6] - 2026-08-15
+
+All of this is about the FutureSDR `HttpSource` block (the `futuresdr`
+feature), whose streaming path turned out to be losing most of the
+stream. Found and measured against a live SPECTRAN V6 ECO running a
+49 MHz survey for a trunking decoder.
+
+### Fixed
+- **The sample buffer guillotined every packet bigger than itself.**
+  The capacity trim runs as each packet lands, and with capacity fixed
+  at `buffer_size * 2` a device sending 49k-sample packets into a
+  16384-sample capacity lost ~75% of every packet before the consumer
+  was offered any of it. Measured live: 61.4 MS/s at the device,
+  0.33 MS/s reaching the pipeline, and digital decode unable to hold
+  frame sync. The capacity now floors at four times the largest packet
+  observed, learned from the stream; the floor only ever raises the
+  configured value.
+- **The initial tune could claim success while the device never
+  moved.** `/control` answers `success=true` whether or not any block
+  applies the command — the same device has been measured both
+  honouring and ignoring the identical full-tuple payload in different
+  mission states. The block's start-up tune now writes the real field
+  names (`centerfreq0`, `decimation0`, `reflevel0`) via `/remoteconfig`
+  to the block discovered by walking the config tree, then reads them
+  back and warns about anything that did not take. Where no such block
+  exists (an IQ-demodulator mission exposes different fields), it falls
+  back to the old `/control` capture command and says the result is
+  unverified. The tune is one-shot: stream restarts after an external
+  retune no longer re-push the source's stale target over it.
+- **Launching an app no longer overwrites the operator's gain.** The
+  builder's reference level was a bare number pushed on every start, so
+  merely starting a flowgraph reset the device to the builder default.
+  It is now optional and left untouched unless the caller set one.
+- **`work()` spun.** The runtime ran it whenever the output port had
+  any room — measured at 106,000–390,000 calls a second averaging 14
+  free samples each — burning ~60% of a core and starving the
+  downstream block. The output port now requires a worthwhile block of
+  room before `work()` runs; call rate dropped to ~14/s.
+
+### Changed
+- **The HTTP socket is drained by a dedicated task**, not inside
+  `work()`. The socket used to be read only while the scheduler happened
+  to run the block, which capped throughput at a tenth of what `curl`
+  pulls from the same endpoint. A background task now pushes chunks
+  into a bounded channel (~10 MB), whose fill is the backpressure point:
+  consumer falls behind → channel fills → reader blocks → TCP flow
+  control stops the server. Measured at a 49 MHz span: 1.8 → ~7–9 MS/s.
+  The honest ceiling is the link (~57 MB/s ≈ 14 MS/s as float32);
+  61.44 MS/s over this transport is 2 Gbit/s and not reachable.
+- Buffer-overflow drops are now counted and logged geometrically
+  rather than once per occurrence, which at wide span was 5040 log
+  lines in 25 seconds for one piece of information.
+- File playback decodes little-endian cf32 with a zero-copy read
+  straight into the sample buffer; the explicit per-sample decode
+  remains for big-endian hosts, and a round-trip test pins the two to
+  identical output.
+
+### Fixed (in review, before this release shipped)
+- The refill loop kept iterating through its 50 ms idle sleeps when the
+  channel was empty, holding samples already in the buffer for up to
+  800 ms before producing them. It now flushes immediately and sleeps
+  only when there is nothing to flush.
+- A parse error mid-stream reconnected without reaping the reader task,
+  which on a stalled socket keeps holding a server connection — on the
+  free licence, the one connection the reconnect needs.
+- Two comments overstated the `/control` finding as "this endpoint does
+  not carry these fields on a Spectran V6". Measured today, the same
+  device honours the identical full-tuple payload — the accurate claim
+  is that `success=true` proves nothing either way, which is the reason
+  the verified `/remoteconfig` path exists. Where no `centerfreq0`
+  block is found, the initial tune now falls back to `/control` rather
+  than silently not tuning (an IQ-demodulator mission exposes
+  `centerfreq`, not `centerfreq0`).
+
+### Added
+- `iq_sample_rate_for_decimation_index`, `decimation_index_for_rate`
+  and `decimation_index_for_bandwidth` in `utils`: the RTSA "Span"
+  enum (`Full` … `1 / 512`) mapped onto the sample-rate ladder and
+  back, so a requested span becomes the enum index the device actually
+  takes.
+- `HttpEndpointsClient::apply_capture_config` — retune via
+  `/remoteconfig` with read-back confirmation — plus
+  `find_block_name_with_field`, which discovers the receiver block by
+  the field the write will target instead of assuming its category.
+
 ## [v0.7.5] - 2026-08-13
 
 ### Added

{python_aaronia-0.7.5 → python_aaronia-0.7.6}/Cargo.lock

@@ -3027,7 +3027,7 @@ dependencies = [
 
 [[package]]
 name = "python-aaronia"
-version = "0.7.5"
+version = "0.7.6"
 dependencies = [
  "arrow",
  "num-complex",
@@ -3556,7 +3556,7 @@ checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
 [[package]]
 name = "sdr-aaronia-rs"
-version = "0.7.5"
+version = "0.7.6"
 dependencies = [
  "anyhow",
  "bitflags 2.13.1",

{python_aaronia-0.7.5 → python_aaronia-0.7.6}/Cargo.toml

@@ -2,7 +2,7 @@
 name = "sdr-aaronia-rs"
 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.7.5"
+version = "0.7.6"
 edition = "2024"
 repository = "https://github.com/isaacbentley/sdr-aaronia-rs"
 readme = "README.md"

{python_aaronia-0.7.5 → python_aaronia-0.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aaronia
-Version: 0.7.5
+Version: 0.7.6
 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.7.5 → python_aaronia-0.7.6}/docs/HTTPSPEC.md

@@ -302,7 +302,12 @@ from `/remoteconfig` first if you need to target one block.
 
 These are one-off requests. Aaronia's own words: if they cannot be
 executed, or conflict with the local configuration, the behaviour is
-undefined — nothing reports the conflict.
+undefined — nothing reports the conflict. That is not theoretical: the
+same device has been measured both honouring and ignoring an identical
+full-tuple capture command in different mission states, answering
+`success=true` both times. A retune that must be provable goes through
+`/remoteconfig` and reads the value back
+(`HttpEndpointsClient::apply_capture_config` does exactly this).
 
 **The settings each `type` accepts**, per Aaronia support (January
 2024), which goes well beyond the published specification:

{python_aaronia-0.7.5 → python_aaronia-0.7.6}/packaging/homebrew/soapy-aaronia.rb

@@ -12,7 +12,7 @@
 class SoapyAaronia < Formula
   desc "SoapySDR plugin for Aaronia SPECTRAN V6 spectrum analyzers"
   homepage "https://github.com/isaacbentley/sdr-aaronia-rs"
-  version "0.7.5"
+  version "0.7.6"
   license "GPL-3.0-or-later"
 
   # Prebuilt modules: the plugin statically links its Rust core, so there

{python_aaronia-0.7.5 → python_aaronia-0.7.6}/python-aaronia/Cargo.toml

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

{python_aaronia-0.7.5 → python_aaronia-0.7.6}/src/file_source.rs

@@ -743,17 +743,42 @@ pub fn rtsa_epoch_seconds(raw: f64) -> f64 {
 /// method call plus a `BufReader` bounds check, which dominates on large
 /// sequential reads.
 fn read_iq_f32<R: Read>(reader: &mut R, count: usize) -> Result<Vec<Complex32>> {
-    let mut bytes = vec![0u8; count * 8];
-    reader.read_exact(&mut bytes)?;
-    Ok(bytes
-        .chunks_exact(8)
-        .map(|c| {
-            Complex32::new(
-                f32::from_le_bytes([c[0], c[1], c[2], c[3]]),
-                f32::from_le_bytes([c[4], c[5], c[6], c[7]]),
-            )
-        })
-        .collect())
+    // The wire format is little-endian f32 pairs, and `Complex32` is
+    // `#[repr(C)] { re: f32, im: f32 }`. On a little-endian host those bytes
+    // are already the in-memory representation, so `from_le_bytes` is a no-op
+    // and reading straight into the sample buffer removes both the separate
+    // byte allocation and the whole per-sample decode pass. The native-SDK
+    // path reinterprets its buffer the same way; this is the file mirror of
+    // it. On a big-endian host the bytes must be swapped, so that path keeps
+    // the explicit decode.
+    const _: () = assert!(std::mem::size_of::<Complex32>() == 2 * std::mem::size_of::<f32>());
+
+    #[cfg(target_endian = "little")]
+    {
+        let mut samples = vec![Complex32::new(0.0, 0.0); count];
+        // SAFETY: `samples` owns `count * 8` contiguous bytes (the repr and
+        // size are asserted above), and `read_exact` writes exactly that many
+        // before it returns; any bit pattern is a valid pair of `f32`.
+        let byte_view =
+            unsafe { std::slice::from_raw_parts_mut(samples.as_mut_ptr() as *mut u8, count * 8) };
+        reader.read_exact(byte_view)?;
+        Ok(samples)
+    }
+
+    #[cfg(not(target_endian = "little"))]
+    {
+        let mut bytes = vec![0u8; count * 8];
+        reader.read_exact(&mut bytes)?;
+        Ok(bytes
+            .chunks_exact(8)
+            .map(|c| {
+                Complex32::new(
+                    f32::from_le_bytes([c[0], c[1], c[2], c[3]]),
+                    f32::from_le_bytes([c[4], c[5], c[6], c[7]]),
+                )
+            })
+            .collect())
+    }
 }
 
 /// Bulk-read `count` little-endian i16 IQ pairs, each component scaled by
@@ -2901,6 +2926,34 @@ impl DsftChunk {
 
 #[cfg(test)]
 mod tests {
+    /// The zero-copy little-endian `read_iq_f32` must decode identically to
+    /// the explicit `from_le_bytes` version. A raw reinterpret is exactly
+    /// where an endianness or layout mistake hides while still producing
+    /// plausible-looking floats.
+    #[test]
+    fn read_iq_f32_round_trips() {
+        let pairs = [
+            (0.0f32, 0.0f32),
+            (1.0, -1.0),
+            (1.5e-3, -2.7e4),
+            (f32::MIN_POSITIVE, 12345.678),
+        ];
+        let mut bytes = Vec::new();
+        for (re, im) in pairs {
+            bytes.extend_from_slice(&re.to_le_bytes());
+            bytes.extend_from_slice(&im.to_le_bytes());
+        }
+
+        let mut cursor = std::io::Cursor::new(bytes);
+        let got = read_iq_f32(&mut cursor, pairs.len()).expect("decode");
+
+        assert_eq!(got.len(), pairs.len());
+        for (g, (re, im)) in got.iter().zip(pairs) {
+            assert_eq!(g.re, re, "re mismatch");
+            assert_eq!(g.im, im, "im mismatch");
+        }
+    }
+
     use super::*;
     use std::io::Cursor;