infinicode 2.8.96 → 2.8.98

package/packages/robopark/scheduler/preview_agent.py

@@ -97,7 +97,7 @@ def _resolve_inventory_audio(items: list, selected: object, preferred: str) -> s
     return str(match.get("name")) if match and match.get("name") else selected_text
 
 
-def _normalize_livekit_url(url: Optional[str]) -> Optional[str]:
+def _normalize_livekit_url(url: Optional[str]) -> Optional[str]:
     """Avoid Windows localhost IPv6/IPv4 ambiguity for local LiveKit."""
     if not url:
         return url
@@ -105,9 +105,54 @@ def _normalize_livekit_url(url: Optional[str]) -> Optional[str]:
         prefix = f"{scheme}://localhost"
         if url.startswith(prefix):
             return f"{scheme}://127.0.0.1" + url[len(prefix):]
-    return url
-
-
+    return url
+
+
+def _pcm16_scale_and_peak(data: bytes, gain: float) -> tuple[bytes, int]:
+    """Apply gain and measure peak without audioop (removed in Python 3.13)."""
+    from array import array
+
+    samples = array("h")
+    samples.frombytes(data[:len(data) - (len(data) % 2)])
+    if sys.byteorder != "little":
+        samples.byteswap()
+    peak = 0
+    for index, value in enumerate(samples):
+        scaled = max(-32768, min(32767, int(value * gain))) if gain != 1.0 else value
+        samples[index] = scaled
+        peak = max(peak, abs(scaled))
+    if sys.byteorder != "little":
+        samples.byteswap()
+    return samples.tobytes(), peak
+
+
+def _pcm16_resample_mono(data: bytes, source_rate: int, target_rate: int) -> bytes:
+    """Linearly resample a PCM16 mono chunk using only the standard library."""
+    from array import array
+
+    if source_rate == target_rate or len(data) < 4:
+        return data
+    source = array("h")
+    source.frombytes(data[:len(data) - (len(data) % 2)])
+    if sys.byteorder != "little":
+        source.byteswap()
+    target_count = max(1, round(len(source) * target_rate / source_rate))
+    target = array("h", [0]) * target_count
+    scale = source_rate / target_rate
+    last = len(source) - 1
+    for index in range(target_count):
+        position = min(last, index * scale)
+        left = int(position)
+        right = min(last, left + 1)
+        fraction = position - left
+        target[index] = max(-32768, min(32767, round(
+            source[left] + (source[right] - source[left]) * fraction
+        )))
+    if sys.byteorder != "little":
+        target.byteswap()
+    return target.tobytes()
+
+
 def _play_audio_effect(selected_output: str | None, effect: str) -> None:
     """Play a short local cue without involving the voice pipeline."""
     sample_rate = 48000
@@ -1733,7 +1778,6 @@ class LiveKitPublisher:
         samples_per_frame = int(48000 * frame_ms / 1000)
         samples_per_batch = int(48000 * BATCH_MS / 1000)
         bytes_per_frame = samples_per_frame * 2  # int16 mono
-        import audioop
         mic_gain = max(1.0, min(float(os.getenv("ROBOPARK_MIC_GAIN", "4.0")), 12.0))
         _diag_peak = 0
         _diag_count = 0
@@ -1751,8 +1795,7 @@ class LiveKitPublisher:
                 _pub_start = time.monotonic()
                 for off in range(0, len(data) - bytes_per_frame + 1, bytes_per_frame):
                     chunk = data[off:off + bytes_per_frame]
-                    if mic_gain != 1.0:
-                        chunk = audioop.mul(chunk, 2, mic_gain)
+                    chunk, p = _pcm16_scale_and_peak(chunk, mic_gain)
                     frame = self.rtc.AudioFrame(
                         data=chunk, sample_rate=48000, num_channels=1, samples_per_channel=samples_per_frame,
                     )
@@ -1763,8 +1806,7 @@ class LiveKitPublisher:
                             "microphone_published", "ok",
                             "Microphone track published with live PCM frames",
                         )
-                    p = audioop.max(chunk, 2)
-                    _diag_peak = max(_diag_peak, p)
+                    _diag_peak = max(_diag_peak, p)
                     _diag_count += 1
                 _diag_read_ms += (_t1 - _t0) * 1000
                 _diag_publish_ms += (time.monotonic() - _pub_start) * 1000
@@ -1971,7 +2013,6 @@ class AlsaAudioCapture(AudioCapture):
         self.media_guard = media_lock("microphone", timeout=1.5).acquire()
         self.process = None
         self.source_rate = 48000
-        self.rate_state = None
         errors = []
         # The fleet USB microphone normally accepts 48 kHz through ALSA's
         # plug layer. Some firmware revisions expose only native 44.1 kHz;
@@ -2006,10 +2047,7 @@ class AlsaAudioCapture(AudioCapture):
                 self.source_rate = source_rate
                 self.alsa_device = alsa_device
                 if source_rate != 48000:
-                    import audioop
-                    first, self.rate_state = audioop.ratecv(
-                        first, 2, 1, source_rate, 48000, self.rate_state
-                    )
+                    first = _pcm16_resample_mono(first, source_rate, 48000)
                 self.buffer.extend(first)
                 break
             except Exception as exc:
@@ -2027,7 +2065,6 @@ class AlsaAudioCapture(AudioCapture):
             raise OSError(f"ALSA capture failed on plug{match.group(1)} ({'; '.join(errors)})")
 
     def read(self, samples_per_frame: int):
-        import audioop
         import os
         from livekit import rtc
 
@@ -2041,9 +2078,7 @@ class AlsaAudioCapture(AudioCapture):
                     detail = self.process.stderr.read().decode("utf-8", errors="replace").strip()
                 raise OSError(f"ALSA capture stopped on {self.alsa_device}: {detail or 'no PCM data'}")
             if self.source_rate != 48000:
-                chunk, self.rate_state = audioop.ratecv(
-                    chunk, 2, 1, self.source_rate, 48000, self.rate_state
-                )
+                chunk = _pcm16_resample_mono(chunk, self.source_rate, 48000)
             self.buffer.extend(chunk)
         data = bytes(self.buffer[:bytes_needed])
         del self.buffer[:bytes_needed]

package/packages/robopark/scheduler/robot_supervisor.py

@@ -403,7 +403,7 @@ def _post_supervisor_output(identity, kind: str, service: Optional[str], payload
         logger.debug(f"supervisor-output POST failed: {e}")
 
 
-def _handle_shell_command(identity, cmd: dict) -> None:
+def _handle_shell_command(identity, cmd: dict) -> None:
     """Process a single shell/log request returned by the scheduler.
 
     `cmd` is {id, kind: "shell_run"|"tail_logs"|"speaker_test", service,
@@ -425,11 +425,68 @@ def _handle_shell_command(identity, cmd: dict) -> None:
         result = _tail_log_file(log_path, int(params.get("lines", 200)))
     elif kind == "shell_run":
         result = _run_shell_command(params.get("name", ""), params)
-    elif kind == "speaker_test":
-        result = _speaker_roundtrip_test(params)
+    elif kind == "speaker_test":
+        result = _speaker_roundtrip_test(params)
+    elif kind == "motor_sequence":
+        result = _run_motor_sequence(params)
     else:
         result = {"ok": False, "error": f"unknown shell command kind: {kind!r}"}
-    _post_supervisor_output(identity, kind, service, result, request_id)
+    _post_supervisor_output(identity, kind, service, result, request_id)
+
+
+def _run_motor_sequence(params: dict) -> dict:
+    """Run one validated scheduler sequence against the robot-local motor API."""
+    import httpx
+    base = str(params.get("motor_server_url") or "http://127.0.0.1:8001").rstrip("/")
+    if not (base.startswith("http://127.0.0.1:") or base.startswith("http://localhost:")):
+        return {"ok": False, "error": "motor server must be robot-local"}
+    registry = {str(item.get("id")): item for item in (params.get("registry") or [])}
+    steps = params.get("steps") or []
+    started = time.monotonic()
+    completed = []
+    try:
+        with httpx.Client(timeout=8.0) as client:
+            existing = client.get(f"{base}/list-motors").json().get("motors", [])
+            existing_names = {str(item.get("name")) for item in existing}
+            for motor_id, motor in registry.items():
+                body = {"name": motor_id, "gpio": int(motor["gpio"]), "active_high": bool(motor.get("active_high", True))}
+                response = (client.put(f"{base}/update-motor/{motor_id}", json=body)
+                            if motor_id in existing_names else client.post(f"{base}/add-motor", json=body))
+                response.raise_for_status()
+            for index, step in enumerate(steps):
+                motor_id = str(step.get("motor_id"))
+                motor = registry.get(motor_id)
+                if not motor:
+                    raise ValueError(f"step {index + 1} references unknown motor {motor_id}")
+                delay_ms = max(0, min(30000, int(step.get("delay_ms", 0))))
+                duration_ms = max(50, min(int(motor.get("max_duration_ms", 3000)), int(step.get("duration_ms", 500))))
+                if delay_ms:
+                    time.sleep(delay_ms / 1000.0)
+                response = client.post(f"{base}/trigger-motor", json={"motor_name": motor_id, "seconds": duration_ms / 1000.0})
+                response.raise_for_status()
+                deadline = time.monotonic() + duration_ms / 1000.0 + 2.0
+                while time.monotonic() < deadline:
+                    status_response = client.get(f"{base}/status")
+                    status_response.raise_for_status()
+                    status = status_response.json()
+                    if status.get("status") == "idle":
+                        if status.get("error"):
+                            raise RuntimeError(f"motor {motor_id} failed: {status['error']}")
+                        break
+                    time.sleep(0.05)
+                else:
+                    raise TimeoutError(f"motor {motor_id} did not return to idle")
+                completed.append({"motor_id": motor_id, "duration_ms": duration_ms})
+    except Exception as exc:
+        try:
+            httpx.post(f"{base}/stop-motors", json={}, timeout=3.0)
+        except Exception:
+            pass
+        return {"ok": False, "error": f"{type(exc).__name__}: {exc}", "completed_steps": completed,
+                "duration_ms": int((time.monotonic() - started) * 1000), "session_id": params.get("session_id")}
+    return {"ok": True, "pass": True, "sequence_id": params.get("sequence_id"), "completed_steps": completed,
+            "duration_ms": int((time.monotonic() - started) * 1000), "motor_server_url": base,
+            "session_id": params.get("session_id")}
 
 
 # ── Speaker roundtrip test (C2 gap-fill) ──
@@ -626,15 +683,92 @@ def _linux_aplay_pcm16(raw: bytes, selected_output: str, sample_rate: int,
     return False, f"{alsa_device}: {last_error}"
 
 
+def _linux_mic_groundtruth(selected_input: str, duration: float = 4.0) -> dict:
+    """Capture the fleet USB mic through the exact onsite-proven ALSA path."""
+    import re
+
+    match = re.search(r"hw:(\d+),(\d+)", str(selected_input), re.IGNORECASE)
+    if not match:
+        return {"ok": False, "error": "selected input has no ALSA hw address"}
+    alsa_device = f"plughw:{match.group(1)},{match.group(2)}"
+    seconds = max(1, min(10, int(round(duration))))
+    command = [
+        "arecord", "-q", "-D", alsa_device, "-t", "raw", "-f", "S16_LE",
+        "-r", "48000", "-c", "1", "-d", str(seconds),
+    ]
+    started = time.monotonic()
+    try:
+        from media_lock import media_lock
+        with media_lock("microphone", timeout=8.0):
+            completed = subprocess.run(
+                command,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                timeout=seconds + 4.0,
+                check=False,
+            )
+    except Exception as exc:
+        return {
+            "ok": False,
+            "mode": "mic_groundtruth",
+            "error": f"{type(exc).__name__}: {exc}",
+            "input_device": alsa_device,
+            "duration_ms": int((time.monotonic() - started) * 1000),
+        }
+    raw = completed.stdout or b""
+    stderr = completed.stderr.decode("utf-8", errors="replace").strip()
+    if completed.returncode != 0 or len(raw) < 2:
+        return {
+            "ok": False,
+            "mode": "mic_groundtruth",
+            "error": stderr or f"arecord exited {completed.returncode}",
+            "exit_code": completed.returncode,
+            "bytes": len(raw),
+            "input_device": alsa_device,
+            "command": " ".join(command),
+            "duration_ms": int((time.monotonic() - started) * 1000),
+        }
+    sample_count = len(raw) // 2
+    peak = 0
+    square_sum = 0
+    nonzero = 0
+    for (value,) in struct.iter_unpack("<h", raw[:sample_count * 2]):
+        magnitude = abs(value)
+        peak = max(peak, magnitude)
+        square_sum += value * value
+        if value:
+            nonzero += 1
+    rms = (square_sum / sample_count) ** 0.5
+    peak_db = round(20.0 * math.log10(max(1, peak) / 32767.0), 1)
+    rms_db = round(20.0 * math.log10(max(1.0, rms) / 32767.0), 1)
+    return {
+        "ok": True,
+        "pass": nonzero > 0 and peak > 0,
+        "mode": "mic_groundtruth",
+        "exit_code": completed.returncode,
+        "bytes": len(raw),
+        "samples": sample_count,
+        "nonzero_samples": nonzero,
+        "nonzero_percent": round(nonzero * 100.0 / sample_count, 3),
+        "recorded_peak": peak,
+        "recorded_peak_db": peak_db,
+        "recorded_rms": round(rms, 2),
+        "recorded_rms_db": rms_db,
+        "sample_rate": 48000,
+        "channels": 1,
+        "input_device": alsa_device,
+        "command": " ".join(command),
+        "stderr": stderr,
+        "duration_ms": int((time.monotonic() - started) * 1000),
+        "diagnostic": "ground truth captured through the onsite-proven ALSA arecord path",
+    }
+
+
 def _speaker_roundtrip_test(params: dict) -> dict:
     """Play a test tone + record the mic simultaneously; return metrics.
 
     params may include {frequency, duration, amplitude, output, input,
     threshold_db}. Anything missing falls back to the module constants."""
-    try:
-        import pyaudio
-    except ImportError as e:
-        return {"ok": False, "error": f"pyaudio not installed on this robot: {e}"}
     mode = str(params.get("mode", "tone")).lower()
     playback_only = bool(params.get("playback_only", mode == "tts"))
     freq = float(params.get("frequency", SPEAKER_TEST_FREQUENCY_HZ))
@@ -646,8 +780,16 @@ def _speaker_roundtrip_test(params: dict) -> dict:
     out_name = params.get("output_name") or params.get("output", os.environ.get("ROBOPARK_AUDIO_OUTPUT") or SPEAKER_TEST_OUTPUT_DEVICE)
     in_name = params.get("input_name") or params.get("input", os.environ.get("ROBOPARK_AUDIO_INPUT") or SPEAKER_TEST_INPUT_DEVICE)
     source_rate = int(params.get("sample_rate", SPEAKER_TEST_SAMPLE_RATE))
+    if mode == "mic_groundtruth":
+        if not sys.platform.startswith("linux"):
+            return {"ok": False, "error": "mic_groundtruth requires Linux ALSA"}
+        return _linux_mic_groundtruth(str(in_name), float(params.get("duration", 4.0)))
     if mode not in ("tone", "tts"):
         return {"ok": False, "error": f"unsupported speaker test mode: {mode}"}
+    try:
+        import pyaudio
+    except ImportError as e:
+        return {"ok": False, "error": f"pyaudio not installed on this robot: {e}"}
     if mode == "tone" and not (50.0 <= freq <= 8000.0):
         return {"ok": False, "error": f"frequency {freq}Hz out of allowed range (50..8000)"}
     if not (0.1 <= dur <= 3.0):
@@ -936,7 +1078,7 @@ def run(config_path: Path) -> None:
                             _execute_command(target, cmd.get("action", "restart"))
                         elif kind == "supervisor_action":
                             logger.warning(f"remote command for unknown service {cmd.get('service_name')!r} ignored")
-                        elif kind in ("shell_run", "tail_logs", "speaker_test"):
+                        elif kind in ("shell_run", "tail_logs", "speaker_test", "motor_sequence"):
                             # run on a background thread so we don't block
                             # the 2s poll loop on a slow command
                             import threading