python-aaronia 0.6.1__tar.gz → 0.7.0__tar.gz

{python_aaronia-0.6.1 → python_aaronia-0.7.0}/CHANGELOG.md

@@ -4,6 +4,55 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [v0.7.0] - 2026-08-12
+
+### Added
+- **`aaronia.open()`, block iteration and context-manager support in
+  Python.** The shortest working program is now three lines. `open()`
+  takes the URL, frequency and either an exact `rate` or the
+  `bandwidth` you want covered, connects, and starts streaming;
+  `for block in src.blocks(65536)` ends when the source runs out
+  instead of raising; and `with` stops the stream even when the body
+  fails, raising a failed teardown only if the body itself succeeded.
+  The old config-object path is unchanged and still the way to reach
+  every option.
+- **`aaronia-doctor`, a command that checks an RTSA server.** It reports
+  whether the server answers, whether the mission has an input carrying
+  IQ, and what rate the device is running, and prints the fix for each
+  failure. The same checks are available as `aaronia.diagnose(url)`,
+  which returns `(ok, message, fix)` tuples, bounded at 20 seconds so a
+  stalled server cannot leave it waiting. Every failure it names is one
+  that otherwise shows up as a timeout with no explanation.
+- **`aaronia.sample_rates()` and `aaronia.sample_rate_for_bandwidth()`**,
+  exposing the crate's rate ladder to Python so a program can ask for a
+  rate the hardware will actually run.
+- **`Error::StreamClosed`**, separating "the stream ended" from "a read
+  failed". Both used to arrive as `Error::Protocol`, so a consumer
+  could not tell a capture that finished from one that was cut short.
+  Rust code matching on `Error::Protocol` for the closed-stream case
+  needs the new variant instead; the enum is `#[non_exhaustive]`, so
+  existing wildcard arms keep compiling. In Python the matching
+  exception is `AaroniaStreamClosed`, a subclass of
+  `AaroniaConnectionError`, so existing handlers are unaffected. It is
+  what lets `blocks()` end a loop on a finished stream while still
+  raising on a timeout or a transport failure, which would otherwise
+  make a truncated capture look like one that simply ran out.
+- **An installer in every SoapySDR release archive.** `install.sh`
+  (`install.ps1` on Windows) finds SoapySDR's module directory, clears
+  the macOS quarantine flag, copies the module in, and confirms it
+  loads. It prints instructions rather than guessing when SoapySDR is
+  missing.
+- **A Homebrew formula for the SoapySDR plugin**, in
+  `packaging/homebrew`. The release workflow renders it against the
+  published archives, checksums included, and attaches it to the
+  release, so updating a tap is a copy.
+
+### Fixed
+- The SoapySDR application guide still listed the old invented sample
+  rates for GQRX. It now describes the real ladder.
+
+## [v0.6.2] - 2026-08-12
+
 ## [v0.6.1] - 2026-08-12
 
 ### Fixed
@@ -30,8 +79,40 @@ All notable changes to this project will be documented in this file.
   guesses, so the relationships now live in one tested place. Wanting
   8 MHz of spectrum needs 10 MHz of sampling, and
   `iq_sample_rate_for_bandwidth` returns the 15.36 MHz that provides it.
+  `iq_sample_rates_for_clock` covers devices whose receiver clock is not
+  the default: a V6 ECO has a fixed clock and gives the measured ladder,
+  while a full V6 can select a faster one and reach further. Aaronia's
+  samples set `device/receiverclock` to "92MHz" or "245MHz"; only the
+  default has been checked against hardware.
+
+### Added (native SDK)
+- **Device-family auto-detection.** `detect_device_family` and
+  `open_detected_device` try each known family in turn, so an ECO owner
+  no longer has to know that the default `spectranv6` will not find
+  their device and that `spectranv6eco` is the string they needed.
+- **`read_spectra`**, with the stream index taken from the open mode
+  rather than assumed. `spectranv6/raw` carries spectra on stream 2 and
+  IQ on stream 0; every other mode uses stream 0. Hardware-unverified.
+- **`receiver_clock_hz`** on the native source, and
+  `spectranv6eco/rtsa` added to the known open modes. The clock sets the
+  rate ladder's ceiling, so callers that need to know which rates exist
+  can now ask instead of assuming.
 
 ### Fixed (native SDK)
+- **The V6 ECO's fixed receiver clock was recorded as 61.44 MHz.** It is
+  92.16 MHz: an ECO streams at 61.44 MHz sampling, measured against real
+  hardware, and the constraint checked at configuration time is
+  `span * 1.5 <= clock`. The old value rejected every span above
+  40.96 MHz, including the device's own maximum.
+- **Dual-channel capture selected the wrong mode and would have
+  returned corrupted samples.** `RxChannel::Rx1And2` wrote
+  `device/receiverchannel = "Rx1+Rx2"`, which delivers the two inputs as
+  two independent streams at indices 0 and 1. This crate reads a single
+  stream and deinterleaves it, which is the contract of the other mode,
+  `"Rx12"`. On a two-input V6 the result would have been Rx1's samples
+  split into two bogus channels, with no error anywhere. It now writes
+  `"Rx12"`. Aaronia's `RawIQ2RX` and `RawIQ2RXInterleave` samples
+  demonstrate one mode each. Still hardware-unverified.
 - **Sweep mode set the wrong resolution-bandwidth key.** It sent
   `main/rbw`, which no Aaronia sample uses; the key is `main/rbwfreq`.
   Checked against Aaronia's published `SweepSpectrumEco` sample, which

{python_aaronia-0.6.1 → python_aaronia-0.7.0}/Cargo.lock

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

{python_aaronia-0.6.1 → python_aaronia-0.7.0}/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.6.1"
+version = "0.7.0"
 edition = "2024"
 repository = "https://github.com/isaacbentley/sdr-aaronia-rs"
 readme = "README.md"

{python_aaronia-0.6.1 → python_aaronia-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aaronia
-Version: 0.6.1
+Version: 0.7.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
@@ -40,37 +40,66 @@ cd python-aaronia
 maturin develop --release
 ```
 
+Check your setup before writing any code:
+
+```bash
+aaronia-doctor http://localhost:54664
+```
+
+It reports whether the server is reachable, whether the mission has an
+input carrying IQ, and what rate the device is running, and names the
+fix for each failure.
+
 ## Quickstart
 
 ```python
 import aaronia
 
-cfg = aaronia.AaroniaConfig()
-cfg.http_base_url = "http://localhost:54664"  # RTSA-Suite HTTP server block
-cfg.center_freq = 2.44e9                      # Hz
-cfg.sample_rate = 15.36e6                     # Hz
-cfg.format = "F32"                            # wire format: F32, F16, or I16
+with aaronia.open("http://localhost:54664", freq=2.44e9, bandwidth=10e6) as src:
+    for block in src.blocks(65536):           # numpy complex64 arrays
+        process(block)
+```
+
+`aaronia.open()` connects and starts streaming in one call. `bandwidth`
+asks for that much usable spectrum and picks a sample rate the hardware
+can actually run; pass `rate=` instead to name one exactly. Use
+`file="capture.rtsa"` in place of the URL to play back a recording.
 
-src = aaronia.AaroniaSource()
-src.start_streaming(cfg)
+Iterating with `blocks()` ends when the stream closes. To read on your
+own schedule, or for Apache Arrow:
 
+```python
+src = aaronia.open(freq=2.44e9, rate=15.36e6, format="I16")
 samples = src.read_samples_numpy(65536)       # numpy complex64 array
 batch = src.read_samples_arrow(65536)         # pyarrow FixedSizeListArray of [re, im]
-
 src.set_center_frequency(2.41e9)              # live retune, no teardown
-
 print(src.cumulative_drops(), src.take_overrun(), src.last_timestamp_ns())
 src.stop_streaming()
 ```
 
-File playback: set `cfg.file_path = "capture.rtsa"` instead of
-`http_base_url`.
+For full control, build an `AaroniaConfig` and pass it to
+`AaroniaSource.start_streaming()`; `open()` is a shorthand for the
+common fields.
 
 The
 [quickstart](https://github.com/isaacbentley/sdr-aaronia-rs/blob/main/docs/QUICKSTART.md)
 covers configuring the RTSA-Suite HTTP Server block, which everything
 above depends on.
 
+## Sample rates
+
+The device runs a fixed ladder of rates: 61.44 MHz halved down to
+120 kHz. Ask for anything else and it quietly uses the nearest rung,
+leaving your program computing against a rate that is not in use.
+
+```python
+aaronia.sample_rates()                  # every rate, highest first
+aaronia.sample_rate_for_bandwidth(8e6)  # 15.36e6: the lowest rate covering 8 MHz
+```
+
+A rate carries only 80% of itself as alias-free bandwidth, which is why
+8 MHz of spectrum needs 15.36 MHz of sampling.
+
 ## Configuration (`AaroniaConfig`)
 
 Every field is readable and writable.
@@ -107,11 +136,14 @@ silently defaulting.
   enabled, which is the default. The reader reopens the stream,
   re-applies the current tuning, and flags the first read after the gap
   through `take_overrun()`. After five failed attempts the stream ends
-  and reads raise `AaroniaConnectionError`.
+  and reads raise `AaroniaStreamClosed`.
 - **Typed exceptions.** `AaroniaConnectionError` (unreachable endpoint),
   `AaroniaTimeoutError`, `AaroniaHardwareError` (device and SDK errors)
   and `ValueError` (invalid configuration), mapped from the Rust error
   enum with the full cause chain in the message.
+  `AaroniaStreamClosed` subclasses `AaroniaConnectionError` and means
+  the stream finished rather than failed; `blocks()` ends on it, while
+  a timeout or transport failure still raises.
 - **Dual-channel** reads (`receiver_channel = "Rx1And2"` with
   `read_samples_dual_numpy(count)`, returning two time-aligned arrays)
   require the native-SDK backend: Windows or Linux with the Aaronia SDK
@@ -123,6 +155,8 @@ silently defaulting.
 | Method | Purpose |
 | --- | --- |
 | `start_streaming(cfg)` / `stop_streaming()` | Session lifecycle |
+| `with src: ...` | Stops streaming on the way out, including after an exception |
+| `blocks(count)` | Iterate `count`-sample arrays until the stream closes |
 | `read_samples_numpy(count)` | NumPy `complex64` array |
 | `read_samples_arrow(count)` | PyArrow `FixedSizeListArray` of `[re, im]` float32 pairs |
 | `read_samples_dual_numpy(count)` | `(rx1, rx2)` NumPy arrays (dual-channel captures) |
@@ -131,3 +165,12 @@ silently defaulting.
 | `take_overrun()` | True once per detected receive-side overrun |
 | `last_timestamp_ns()` | Epoch-ns timestamp of the last received block (HTTP backend; 0 otherwise) |
 
+## Module functions
+
+| Function | Purpose |
+| --- | --- |
+| `open(url=None, *, freq, rate, bandwidth, ref_level, file, format, read_timeout)` | Configure, connect and start streaming in one call |
+| `sample_rates()` | Every sample rate the hardware can run |
+| `sample_rate_for_bandwidth(hz)` | Lowest rate covering that much spectrum |
+| `diagnose(url)` | `(ok, message, fix)` for each setup check; what `aaronia-doctor` prints |
+

{python_aaronia-0.6.1 → python_aaronia-0.7.0}/README.md

@@ -102,21 +102,17 @@ pip install python-aaronia
 ```python
 import aaronia
 
-cfg = aaronia.AaroniaConfig()
-cfg.http_base_url = "http://localhost:54664"
-cfg.center_freq = 2.44e9
-cfg.sample_rate = 15.36e6
-
-src = aaronia.AaroniaSource()
-src.start_streaming(cfg)
-samples = src.read_samples_numpy(65536)   # numpy complex64
-src.stop_streaming()
+with aaronia.open("http://localhost:54664", freq=2.44e9, bandwidth=10e6) as src:
+    for block in src.blocks(65536):   # numpy complex64 arrays
+        process(block)
 ```
 
 Reads land in NumPy or PyArrow with one copy out of the receive buffer.
 Blocking calls release the GIL, errors arrive as typed exceptions, and
 the package ships type stubs. Wheels are abi3 for CPython 3.9 and
-later. Full reference: [python-aaronia/README.md](python-aaronia/README.md).
+later. The bundled `aaronia-doctor` command checks a server and names
+the fix for whatever is wrong. Full reference:
+[python-aaronia/README.md](python-aaronia/README.md).
 
 ### SoapySDR: GQRX, SDR++, GNU Radio and others
 

{python_aaronia-0.6.1 → python_aaronia-0.7.0}/docs/APPS.md

@@ -1,14 +1,20 @@
 # Using a SPECTRAN from existing SDR applications
 
 Any SoapySDR-capable application can drive a SPECTRAN through the
-[`soapy-aaronia`](../soapy-aaronia/README.md) plugin. Install the plugin
-first. Prebuilt binaries are attached to each release. Confirm it is
-visible:
+[`soapy-aaronia`](../soapy-aaronia/README.md) plugin. Install it first:
+download the archive for your platform from a
+[release](https://github.com/isaacbentley/sdr-aaronia-rs/releases),
+unpack it, and run the bundled installer (`./install.sh`, or
+`.\install.ps1` in PowerShell on Windows). It finds SoapySDR's module
+directory, copies the plugin in, and confirms it loads:
 
 ```bash
 SoapySDRUtil --check=aaronia
 ```
 
+The [plugin README](../soapy-aaronia/README.md#install-a-prebuilt-module)
+covers installing by hand and building from source.
+
 Every application below uses the same device string. In most cases the
 RTSA-Suite HTTP server URL is the only argument needed:
 
@@ -43,11 +49,10 @@ GQRX accepts a device string directly in its configuration dialog:
 driver=aaronia,url=http://localhost:54664
 ```
 
-Select the sample rate from GQRX's list. The plugin advertises 250 kHz,
-500 kHz, 1, 2, 5, 10, 15.36, 20, 30.72 and 61.44 MHz for applications
-that build dropdowns from `listSampleRates`. Rates within the reported
-range also work over HTTP, so a rate absent from the list is not
-necessarily unsupported.
+Select the sample rate from GQRX's list. The plugin advertises the
+device's real ladder: 61.44 MHz halved down to 120 kHz, which the RTSA
+GUI labels Full through 1/512. The hardware produces no other rate, so a
+request in between snaps to the nearest rung and logs a warning.
 
 The single gain element is `REF`, the Aaronia reference level in dBm. It
 is not an amplifier gain: raising it reduces sensitivity. Start near

{python_aaronia-0.6.1 → python_aaronia-0.7.0}/docs/HTTPSPEC.md

@@ -590,6 +590,44 @@ Data captured using antennas with location or directional information.
 | `azimuth` | Azimuth of directional antenna |
 | `declination` | Declination of directional antenna |
 
+## What the native SDK samples tell us about this API
+
+Aaronia's [C++ SDK samples](https://github.com/Aaronia-Open-source/RTSA-API-Samples)
+drive the same hardware through a different transport, so some of what
+they establish applies here and some does not.
+
+### GPS needs enabling, over HTTP too
+
+The `device/gpsmode` and `device/sclksource` keys the `GPSTime` sample
+writes are the same keys this config tree exposes, so the prerequisite
+is identical. A device ships with `gpsmode` set to `Disabled` and takes
+its stream clock from whatever `sclksource` names, which on the system
+tested here was `10MHz` rather than GPS. Timestamps are not
+GPS-disciplined until both change, and nothing reports an error
+meanwhile.
+
+Observed on a V6 ECO: `gpsmode` offers `Disabled`, `Location`, `Time`
+and `Location and Time`; `sclksource` offers `Consumer`, `Oscillator`,
+`GPS`, `PPS`, `10MHz` and three `... Provider` variants.
+
+### The rate ladder carries over
+
+`decimation0` takes the same labels as the SDK's `main/decimation`,
+`"Full"` through `"1 / 512"`, verified by writing one over HTTP. Both
+transports drive the same divider.
+
+### Two things that do not carry over
+
+- **Receiver-channel selection.** There is no `device/receiverchannel`
+  here. The tree exposes per-channel settings instead — `centerfreq0`
+  and `centerfreq1`, `decimation0` and `decimation1`, `rfchsource0` and
+  `rfchsource1` — and which channels reach the stream is a property of
+  the RTSA mission graph. The SDK's `Rx12` versus `Rx1+Rx2` distinction
+  has no equivalent.
+- **Stream indices.** The SDK separates IQ from spectra by packet stream
+  index. HTTP selects data with the `input=` parameter and reports the
+  kind in each packet's `payload` field.
+
 ## Authorization & Licensing
 
 ### HTTP Streaming vs Remote Configuration

{python_aaronia-0.6.1 → python_aaronia-0.7.0}/docs/QUICKSTART.md

@@ -86,30 +86,39 @@ cargo run --example http_iq_quickstart --features http -- 2440e6 15.36e6 http://
 pip install python-aaronia
 ```
 
+Check the server first. The command ships with the package and reports
+what is wrong, and how to fix it:
+
+```bash
+aaronia-doctor http://localhost:54664
+```
+
 ```python
 import aaronia
 
-cfg = aaronia.AaroniaConfig()
-cfg.http_base_url = "http://localhost:54664"
-cfg.center_freq = 2.44e9
-cfg.sample_rate = 15.36e6
-
-src = aaronia.AaroniaSource()
-src.start_streaming(cfg)
-samples = src.read_samples_numpy(65536)   # numpy complex64
-print(samples[:4], src.cumulative_drops())
-src.stop_streaming()
+with aaronia.open("http://localhost:54664", freq=2.44e9, bandwidth=10e6) as src:
+    samples = src.read_samples_numpy(65536)   # numpy complex64
+    print(samples[:4], src.cumulative_drops())
 ```
 
+`bandwidth` picks a sample rate the hardware can run. Pass `rate=` to
+name one exactly, or build an `AaroniaConfig` for the full set of
+options.
+
 ### SoapySDR
 
+Download the plugin archive for your platform from a
+[release](https://github.com/isaacbentley/sdr-aaronia-rs/releases),
+unpack it, and run the bundled installer:
+
 ```bash
+./install.sh
 SoapySDRUtil --probe="driver=aaronia,url=http://localhost:54664"
 ```
 
 [APPS.md](APPS.md) covers GQRX, SDR++ and GNU Radio.
 [../soapy-aaronia/README.md](../soapy-aaronia/README.md) covers
-installing the plugin.
+installing by hand and building from source.
 
 ## 4. Troubleshooting
 

{python_aaronia-0.6.1 → python_aaronia-0.7.0}/docs/SDKSPEC.md

@@ -876,3 +876,61 @@ the Aaronia Software License Agreement governs use of the SDK itself (see
 [Licensing Considerations](#licensing-considerations)); this community document
 describes only the public interface. "Aaronia", "RTSA", and "Spectran" are the
 property of Aaronia AG.
+
+## Facts taken from Aaronia's published samples
+
+The following come from
+[Aaronia-Open-source/RTSA-API-Samples](https://github.com/Aaronia-Open-source/RTSA-API-Samples),
+read in full. They are vendor code rather than vendor documentation, but
+they are the closest thing to an authoritative statement of how the API
+is meant to be driven, and this crate's native-SDK paths cannot be
+tested here.
+
+### Both receivers, two different modes
+
+`device/receiverchannel` takes four values, and the last two are not
+interchangeable:
+
+| Value | Delivery |
+| --- | --- |
+| `Rx1`, `Rx2` | One input, one stream |
+| `Rx12` | Both inputs interleaved into **one** stream: four floats per sample, `[I0, Q0, I1, Q1]`, read from stream 0 |
+| `Rx1+Rx2` | Both inputs as **two independent streams**, fetched and consumed separately at indices 0 and 1 |
+
+`RawIQ2RXInterleave` uses the first, `RawIQ2RX` the second. This crate
+reads a single stream and deinterleaves it, so it writes `Rx12`.
+
+### V6 against V6 ECO
+
+| | Full V6 | V6 ECO |
+| --- | --- | --- |
+| Family string | `spectranv6` | `spectranv6eco` |
+| `device/receiverchannel` | Set explicitly | Never set: one receiver |
+| `device/receiverclock` | Set, `"92MHz"` or `"245MHz"` | Never set: fixed |
+| Spectrum packets | Stream index 2 | Stream index 0 |
+| Raw-mode open string | `spectranv6/raw` | `spectranv6eco/rtsa` |
+
+The clock matters beyond configuration: with `span * 1.5 <=
+receiverclock`, a V6 on the fast clock reaches roughly 163 MHz of span
+where the ECO's fixed clock allows 61.44 MHz.
+
+### Sample rates
+
+`main/decimation` accepts either the label (`"1 / 64"`) or the index
+(`6`). Combined with the clock, that gives the rate ladder: the top rate
+is `receiverclock / 1.5` and each step halves it.
+
+### Transmitting
+
+The samples flag the first packet `SEGMENT_START | STREAM_START`, the
+last `SEGMENT_END | STREAM_END`, and everything between `0`. The
+transceiver samples additionally send a zero-length packet carrying only
+`STREAM_START`, timestamped at the master stream clock, before real
+data, to improve startup synchronisation.
+
+### Keys this crate does not use
+
+`device/outputformat` (`"iq"` or `"spectra"`), `main/demodcenterfreq`
+and `main/demodspanfreq`, `main/centerfreqtx` and `main/centerfreqrx`
+for independent transceiver tuning, `calibration/preamp`, and the
+read-only `boostusbbytessecond` throughput reading.

{python_aaronia-0.6.1 → python_aaronia-0.7.0}/docs/VERIFICATION.md

@@ -21,7 +21,10 @@ SDK are marked unverified.
 | SoapySDR plugin RX | HTTP | Verified manually (~9.7 Msps via `SoapySDRUtil`); no automated live test, as a `soapysdr` dev-dependency would make `cargo test` unbuildable without system SoapySDR |
 | Python bindings RX | HTTP | Verified manually (NumPy and Arrow); no automated live test |
 | TX (`UnifiedSink`, `aaronia_sink_*`, SoapySDR TX) | Native SDK | **Hardware-unverified**. No TX-licensed device available |
-| Dual-channel RX (`Rx1And2`, `read_samples_dual`) | Native SDK | **Hardware-unverified**. Requires a full V6 |
+| Dual-channel RX (`Rx1And2`, `read_samples_dual`) | Native SDK | **Hardware-unverified**. Requires a full V6. Selects `Rx12`, the interleaved single-stream mode, matching how this crate reads |
+| Spectra reads (`read_spectra`) | Native SDK | **Hardware-unverified**. Packet layout and stream index follow Aaronia's `RawSpectrum` sample |
+| Device-family detection (`open_detected_device`) | Native SDK | **Hardware-unverified**. Enumerates each known family in turn |
+| Sample-rate ladder and usable bandwidth | Both | **Live-verified at the default clock** on a V6 ECO, rung by rung. Faster receiver clocks are inferred from the documented constraint, not measured |
 | GPS hardware time | Native SDK | **Hardware-unverified** |
 | Native SDK capture generally | Native SDK | **Hardware-unverified**; compiled and unit-tested in a Linux VM each release |
 | HTTP TX push (`/sample`) | HTTP | Endpoint exercised live; RF output not measured |
@@ -40,6 +43,15 @@ cargo test --all-features --test live_smoke -- --ignored --nocapture
 Contributions that convert an unverified row, particularly from users
 with a full V6 or a TX licence, are welcome.
 
+Native-SDK entries carry a second qualifier worth stating plainly: they
+are not merely untested, they run on a platform this project cannot
+build on locally. They are compile-checked for Linux and Windows and
+their logic is drawn from Aaronia's published samples, which caught
+three real defects, but nothing has executed them against a device.
+
+If you have a full V6 or a TX licence, closing one of these rows is the
+single most valuable contribution you can make to this crate.
+
 ## Related
 
 - [QUICKSTART.md](QUICKSTART.md) — setting up an RTSA-Suite mission.

python_aaronia-0.7.0/packaging/homebrew/README.md

@@ -0,0 +1,43 @@
+# Homebrew tap
+
+`soapy-aaronia.rb` installs the prebuilt SoapySDR plugin from a GitHub
+release. It is kept here so it is versioned alongside the code it
+installs, and published from a tap repository.
+
+## One-time setup
+
+Create a public repository named `homebrew-tap` under the same owner as
+this one. The name is fixed: Homebrew maps `owner/tap` to
+`github.com/owner/homebrew-tap`. Add the formula as
+`Formula/soapy-aaronia.rb`.
+
+Users then install with:
+
+```bash
+brew install isaacbentley/tap/soapy-aaronia
+```
+
+Homebrew pulls in SoapySDR, drops the module into
+`lib/SoapySDR/modules0.8`, and its `brew test` step confirms
+`SoapySDRUtil --check=aaronia` reports the driver as present.
+
+## Each release
+
+The release workflow renders this file against the published archives
+and attaches the result to the release as `soapy-aaronia.rb`, with the
+version and both SHA-256 checksums filled in. Copy that file into the
+tap repository as `Formula/soapy-aaronia.rb` and commit. Nothing needs
+hashing by hand.
+
+Before pushing, `brew audit --strict --online soapy-aaronia` checks the
+formula, and `brew install --build-from-source` proves it works.
+
+## Coverage
+
+The formula covers macOS on Apple silicon and Linux on x86-64, matching
+the platforms the release builds. Elsewhere, `brew` has nothing to
+install and the plugin has to be built from source; see
+[soapy-aaronia/README.md](../../soapy-aaronia/README.md).
+
+The module directory is pinned to `modules0.8`, which is SoapySDR's ABI
+0.8 path. A future SoapySDR ABI bump requires changing that line.

python_aaronia-0.7.0/packaging/homebrew/soapy-aaronia.rb

@@ -0,0 +1,47 @@
+# Homebrew formula for the Aaronia SoapySDR plugin.
+#
+# Lives here so it is versioned with the code it installs. To publish it,
+# copy this file into a tap repository named homebrew-tap, as
+# Formula/soapy-aaronia.rb, and users get:
+#
+#     brew install <owner>/tap/soapy-aaronia
+#
+# At each release, update `version`, both `sha256` values (from the
+# release archives) and nothing else. `brew audit --strict soapy-aaronia`
+# checks the formula before publishing.
+class SoapyAaronia < Formula
+  desc "SoapySDR plugin for Aaronia SPECTRAN V6 spectrum analyzers"
+  homepage "https://github.com/isaacbentley/sdr-aaronia-rs"
+  version "0.7.0"
+  license "GPL-3.0-or-later"
+
+  # Prebuilt modules: the plugin statically links its Rust core, so there
+  # is nothing to build here and no Rust toolchain to depend on.
+  on_macos do
+    on_arm do
+      url "https://github.com/isaacbentley/sdr-aaronia-rs/releases/download/v#{version}/SoapyAaronia-#{version}-macos-arm64.tar.gz"
+      sha256 "REPLACE_WITH_SHA256_OF_MACOS_ARM64_ARCHIVE"
+    end
+  end
+
+  on_linux do
+    on_intel do
+      url "https://github.com/isaacbentley/sdr-aaronia-rs/releases/download/v#{version}/SoapyAaronia-#{version}-linux-x86_64.tar.gz"
+      sha256 "REPLACE_WITH_SHA256_OF_LINUX_X86_64_ARCHIVE"
+    end
+  end
+
+  depends_on "soapysdr"
+
+  def install
+    # SoapySDR loads modules from a versioned directory under its own
+    # prefix; Homebrew links this into place for us.
+    (lib/"SoapySDR/modules0.8").install "libaaroniaSupport.so"
+    doc.install "INSTALL.md"
+  end
+
+  test do
+    # Proves the module loads into SoapySDR rather than merely existing.
+    assert_match "aaronia", shell_output("#{Formula["soapysdr"].bin}/SoapySDRUtil --check=aaronia")
+  end
+end

{python_aaronia-0.6.1 → python_aaronia-0.7.0}/pyproject.toml

@@ -18,6 +18,11 @@ classifiers = [
 # Version comes from python-aaronia/Cargo.toml (single source of truth).
 dynamic = ["version"]
 
+# A real command, so checking a setup needs no code:
+#   aaronia-doctor http://localhost:54664
+[project.scripts]
+aaronia-doctor = "aaronia:doctor_cli"
+
 [project.urls]
 Repository = "https://github.com/isaacbentley/sdr-aaronia-rs"
 Changelog = "https://github.com/isaacbentley/sdr-aaronia-rs/blob/main/CHANGELOG.md"

{python_aaronia-0.6.1 → python_aaronia-0.7.0}/python-aaronia/Cargo.toml

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