solves review comments

Author: Josephrp

radioshaq/radioshaq/radio/sdr_tx.py

@@ -72,11 +72,13 @@ def __init__(
         audit_log_path: str | None = None,
         restricted_region: str = "FCC",
         band_plan_source: dict[str, BandPlan] | None = None,
+        rig_or_sdr: str = "hackrf",
     ) -> None:
         self.allow_bands_only = allow_bands_only
         self.audit_log_path = audit_log_path
         self.restricted_region = restricted_region
         self._band_plan_source = band_plan_source
+        self._rig_or_sdr = rig_or_sdr
 
     def _check_compliance(self, frequency_hz: float, occupied_bandwidth_hz: float | None = None) -> None:
         """Raise ValueError if TX not allowed on this frequency."""
@@ -125,7 +127,7 @@ def _audit(
             frequency_hz=frequency_hz,
             duration_sec=duration_sec,
             mode=mode,
-            rig_or_sdr="hackrf",
+            rig_or_sdr=self._rig_or_sdr,
             operator_id=None,
             audit_log_path=self.audit_log_path,
             success=success,
@@ -304,6 +306,7 @@ def __init__(
             audit_log_path=audit_log_path,
             restricted_region=restricted_region,
             band_plan_source=band_plan_source,
+            rig_or_sdr="hackrf_broker",
         )
         self._base_url = base_url.rstrip("/")
         self._auth_token = auth_token

radioshaq/radioshaq/remote_receiver/server.py

@@ -334,17 +334,18 @@ async def tx_tone(
         loop = asyncio.get_running_loop()
 
         async def _fn(dev: Any) -> None:
-            # Generate a simple tone in int8 interleaved I/Q, matching HackRF expectations.
-            tone_hz = 1000.0
-            num_samples = int(duration_sec * sample_rate)
-            t = np.arange(num_samples, dtype=np.float64) / sample_rate
-            i = (127 * 0.3 * np.cos(2 * np.pi * tone_hz * t)).astype(np.int8)
-            q = (127 * 0.3 * np.sin(2 * np.pi * tone_hz * t)).astype(np.int8)
-            iq = np.empty(2 * num_samples, dtype=np.int8)
-            iq[0::2] = i
-            iq[1::2] = q
-
             def _blocking_tx() -> None:
+                # Generate tone and run TX in thread pool to avoid blocking the event loop
+                # (NumPy ops for up to ~60M samples can take hundreds of ms).
+                tone_hz = 1000.0
+                num_samples = int(duration_sec * sample_rate)
+                t = np.arange(num_samples, dtype=np.float64) / sample_rate
+                i = (127 * 0.3 * np.cos(2 * np.pi * tone_hz * t)).astype(np.int8)
+                q = (127 * 0.3 * np.sin(2 * np.pi * tone_hz * t)).astype(np.int8)
+                iq = np.empty(2 * num_samples, dtype=np.int8)
+                iq[0::2] = i
+                iq[1::2] = q
+                buf = iq.tobytes()
                 try:
                     dev.center_freq = int(frequency_hz)
                     dev.sample_rate = sample_rate
@@ -356,7 +357,6 @@ def _blocking_tx() -> None:
                     # Older or stub objects may not expose these attributes.
                     pass
                 try:
-                    buf = iq.tobytes()
                     stream_hackrf_iq_bytes(dev, buf, duration_sec)
                 except (AttributeError, TypeError) as e:
                     # Stub/test device or API mismatch — warn and skip (non-fatal for audit).
@@ -638,13 +638,15 @@ async def tx_tone(request: Request) -> dict[str, Any]:
             operator_id = receiver.station_id
         except Exception:
             operator_id = None
+        audit_log_path = os.environ.get("TX_AUDIT_LOG_PATH") or None
         log_tx(
             frequency_hz=frequency_hz,
             duration_sec=duration_sec,
             mode="tone",
             rig_or_sdr="hackrf_broker",
             operator_id=operator_id,
             success=tx_succeeded,
+            audit_log_path=audit_log_path,
         )
     return {"success": True, "notes": "HackRF tone transmitted via remote receiver"}
 
@@ -764,6 +766,7 @@ async def tx_iq(request: Request) -> dict[str, Any]:
             operator_id = receiver.station_id
         except Exception:
             pass
+        audit_log_path = os.environ.get("TX_AUDIT_LOG_PATH") or None
         log_tx(
             frequency_hz=frequency_hz,
             duration_sec=duration_sec,
@@ -772,6 +775,7 @@ async def tx_iq(request: Request) -> dict[str, Any]:
             operator_id=operator_id,
             occupied_bandwidth_hz=occupied_bandwidth_hz,
             success=tx_succeeded,
+            audit_log_path=audit_log_path,
         )
     return {"success": True, "notes": "HackRF IQ transmitted via remote receiver"}
 

radioshaq/radioshaq/specialized/radio_tx.py

@@ -152,10 +152,14 @@ async def _transmit_voice(
                         raise RuntimeError(
                             "SDR voice TX from file requires optional deps: uv sync --extra voice_tx"
                         ) from e
-                    data, sr = sf.read(str(audio_path), dtype="float32", always_2d=False)
-                    # Modulate to 2 MHz (HackRF-friendly); run CPU-heavy scipy in executor to avoid blocking event loop.
                     tx_rate = 2_000_000
                     loop = asyncio.get_running_loop()
+                    # Run blocking file I/O in executor to avoid stalling the event loop.
+                    data, sr = await loop.run_in_executor(
+                        None,
+                        lambda: sf.read(str(audio_path), dtype="float32", always_2d=False),
+                    )
+                    # Modulate to 2 MHz (HackRF-friendly); run CPU-heavy scipy in executor to avoid blocking event loop.
                     if mode_name.value in ("NFM",):
                         iq = await loop.run_in_executor(
                             None, lambda: nfm_modulate(data, int(sr), tx_rate, deviation_hz=2_500.0)