aether-robotics 3.4.0__tar.gz → 3.4.2__tar.gz

{aether_robotics-3.4.0/aether_robotics.egg-info → aether_robotics-3.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aether-robotics
-Version: 3.4.0
+Version: 3.4.2
 Summary: Autonomous multi-agent robotics system with DRL-First Hybrid FDIR
 Author: Chahel Paatur
 License: MIT
@@ -45,7 +45,7 @@ Dynamic: license-file
   <img src="https://img.shields.io/badge/license-MIT-green?style=flat-square" alt="License: MIT">
   <img src="https://img.shields.io/github/stars/ChahelPaatur/AETHER?style=flat-square" alt="GitHub Stars">
   <img src="https://img.shields.io/badge/platform-Linux%20%7C%20macOS%20%7C%20Raspberry%20Pi%20%7C%20Jetson-lightgrey?style=flat-square" alt="Platforms">
-  <img src="https://img.shields.io/badge/version-3.3.3-red?style=flat-square" alt="v3.3.3">
+  <img src="https://img.shields.io/badge/version-3.4.0-red?style=flat-square" alt="v3.4.0">
 </p>
 
 ```

{aether_robotics-3.4.0 → aether_robotics-3.4.2}/README.md

@@ -4,7 +4,7 @@
   <img src="https://img.shields.io/badge/license-MIT-green?style=flat-square" alt="License: MIT">
   <img src="https://img.shields.io/github/stars/ChahelPaatur/AETHER?style=flat-square" alt="GitHub Stars">
   <img src="https://img.shields.io/badge/platform-Linux%20%7C%20macOS%20%7C%20Raspberry%20Pi%20%7C%20Jetson-lightgrey?style=flat-square" alt="Platforms">
-  <img src="https://img.shields.io/badge/version-3.3.3-red?style=flat-square" alt="v3.3.3">
+  <img src="https://img.shields.io/badge/version-3.4.0-red?style=flat-square" alt="v3.4.0">
 </p>
 
 ```

aether_robotics-3.4.2/VERSION

@@ -0,0 +1 @@
+3.4.2

{aether_robotics-3.4.0 → aether_robotics-3.4.2}/aether/__init__.py

@@ -1,2 +1,2 @@
-__version__ = "3.4.0"
+__version__ = "3.4.2"
 __author__ = "Chahel Paatur"

{aether_robotics-3.4.0 → aether_robotics-3.4.2}/aether/agents/correction_agent.py

@@ -28,6 +28,15 @@ _SYSTEM_PROMPT = (
     "do NOT suggest pip install. Instead, suggest an alternative tool that "
     "provides similar functionality (e.g. capture_image uses picamera2 as "
     "fallback, measure_brightness and detect_motion work without cv2).\n\n"
+    "- For continuous-rotation servo corrections (servo_type='continuous'), "
+    "angle is speed in the range -100..+100: 100 = full forward / clockwise "
+    "(180° PWM pulse), -100 = full reverse / counter-clockwise (0° PWM pulse), "
+    "0 = stop (90° PWM pulse). When the original intent was motion — 'go', "
+    "'move', 'forward', 'start', 'clockwise', 'drive' — use angle=100, "
+    "NEVER angle=90. angle=90 on a continuous servo means STOP.\n"
+    "- When a calibrated action tool fails and you fall back to servo_set or "
+    "motor_forward/motor_turn, use the BCM pin from 'Original tool metadata' "
+    "provided in the request, NOT the default pin=18.\n\n"
     "Return valid JSON only — no markdown, no explanation, no code fences:\n"
     "{\n"
     '  "success": true/false,\n'
@@ -115,6 +124,10 @@ class CorrectionAgent:
         expected = step.get("expected_output", "")
         params = step.get("params", {})
 
+        # Extract physical_map metadata from the registered tool (Bug B)
+        tool_obj = registry.get(tool_name)
+        tool_metadata = getattr(tool_obj, "metadata", {}) or {}
+
         # If no expected_output defined, skip LLM evaluation —
         # just use the result's own success flag
         if not expected:
@@ -153,7 +166,8 @@ class CorrectionAgent:
                 # No fallback worked — still try the LLM loop below
 
         while attempt < MAX_RETRIES:
-            verdict = self._call_llm(tool_name, params, expected, actual)
+            verdict = self._call_llm(
+                tool_name, params, expected, actual, tool_metadata)
             if verdict is None:
                 # API failed — trust the result as-is
                 break
@@ -175,6 +189,22 @@ class CorrectionAgent:
             corr_tool = verdict.get("correction_tool")
             corr_inputs = verdict.get("correction_inputs") or {}
 
+            # Belt-and-suspenders: when falling back to a servo/motor tool,
+            # enforce the BCM pin from the original tool's metadata regardless
+            # of what the LLM proposed — deterministic, not probabilistic.
+            _PIN_FALLBACK_TOOLS = {"servo_set", "motor_forward", "motor_turn"}
+            if tool_metadata and corr_tool in _PIN_FALLBACK_TOOLS:
+                meta_bcm = tool_metadata.get("bcm")
+                if meta_bcm is not None:
+                    corr_inputs = dict(corr_inputs)
+                    pin_keys = (["pin"] if corr_tool == "servo_set"
+                                else ["left_pin", "right_pin"])
+                    for pk in pin_keys:
+                        if corr_inputs.get(pk) != meta_bcm:
+                            corr_inputs[pk] = meta_bcm
+                            print(f"    [CORRECT] Overrode {pk} → "
+                                  f"BCM {meta_bcm} from original tool metadata")
+
             correction_entry = {
                 "attempt": attempt,
                 "issue": issue,
@@ -227,11 +257,17 @@ class CorrectionAgent:
         }
 
     def _call_llm(self, tool: str, params: Dict, expected: str,
-                  actual: str) -> Optional[Dict]:
+                  actual: str,
+                  tool_metadata: Optional[Dict] = None) -> Optional[Dict]:
         """Call the Anthropic API to evaluate step success."""
+        meta_line = ""
+        if tool_metadata:
+            meta_line = (f"Original tool metadata: "
+                         f"{json.dumps(tool_metadata)}\n")
         user_msg = (
             f"Tool: {tool}\n"
             f"Inputs: {json.dumps(params, default=str)[:500]}\n"
+            f"{meta_line}"
             f"Expected: {expected}\n"
             f"Got: {actual}\n\n"
             f"Available tools for corrections: {', '.join(self._available_tools)}\n\n"

{aether_robotics-3.4.0 → aether_robotics-3.4.2}/aether/app.py

@@ -9,10 +9,12 @@ All paths to data files (configs/, context/, weights/) are resolved
 relative to the *project root*, which is auto-detected at import time.
 """
 import argparse
+import atexit
 import json
 import logging
 import os
 import re
+import signal as _signal
 import sys
 import time
 
@@ -88,6 +90,60 @@ def silence_http_logging() -> None:
     logging.getLogger("httpx").setLevel(logging.WARNING)
 
 
+# ── GPIO cleanup on exit ──────────────────────────────────────────────
+
+_gpio_cleanup_registered = False
+_gpio_nav_refs: list = []   # holds nav_engine references for PWM draining
+
+
+def _register_gpio_cleanup(nav_engine=None) -> None:
+    """Register atexit + SIGINT/SIGTERM handlers that drain PWMs and call
+    GPIO.cleanup().  Safe to call multiple times — registers only once.
+    """
+    global _gpio_cleanup_registered
+    if _gpio_cleanup_registered:
+        return
+    _gpio_cleanup_registered = True
+
+    if nav_engine is not None:
+        _gpio_nav_refs.append(nav_engine)
+
+    def _do_cleanup():
+        # 1. Stop live PWM instances held by NavigationEngine._motors
+        for nav in _gpio_nav_refs:
+            motors = getattr(nav, "_motors", None)
+            if motors is not None:
+                pwm_map = getattr(motors, "_pwm_instances", {})
+                n = len(pwm_map)
+                for pwm_obj in list(pwm_map.values()):
+                    try:
+                        pwm_obj.stop()
+                    except Exception:
+                        pass
+                pwm_map.clear()
+                if n:
+                    print(f"\n[GPIO] Stopped {n} active PWM instance(s)")
+        # 2. Full GPIO cleanup
+        try:
+            import RPi.GPIO as GPIO
+            GPIO.cleanup()
+            print("\n[GPIO] Released all pins on exit")
+        except Exception:
+            pass
+
+    atexit.register(_do_cleanup)
+
+    def _sig_handler(sig, frame):
+        _do_cleanup()
+        sys.exit(0)
+
+    try:
+        _signal.signal(_signal.SIGINT,  _sig_handler)
+        _signal.signal(_signal.SIGTERM, _sig_handler)
+    except Exception:
+        pass  # not on main thread in some test runners
+
+
 def run_sim(args) -> None:
     """Existing simulation mode — unchanged."""
     from aether.simulation.environment import SimulationEnvironment
@@ -482,6 +538,7 @@ def run_agent(args) -> None:
             _print_activity("OLED", f"startup animation failed: {e}")
 
     nav_engine = NavigationEngine(discovery.manifest, tools=built_tools)
+    _register_gpio_cleanup(nav_engine)   # drain PWMs + GPIO.cleanup on exit
     nav_actions = nav_engine.available_actions()
     _print_activity("NAV", f"Level {nav_engine.level} ({nav_engine.level_name}) — "
                     f"{len(nav_actions)} navigation actions")
@@ -1720,6 +1777,7 @@ def main():
         discovery.discover()
         discovery.print_summary()
 
+        _register_gpio_cleanup()   # GPIO.cleanup on exit during calibration
         auto_mode = getattr(args, "auto_calibrate", False)
         wizard = CalibrationWizard(
             discovery.manifest,

{aether_robotics-3.4.0 → aether_robotics-3.4.2}/aether/core/calibration.py

@@ -131,6 +131,14 @@ _CATEGORY_ACTION_PREFIX: Dict[int, str] = {
     6: "motor",
 }
 
+# Stopwords stripped before slugifying descriptions (Bug 4)
+_SLUG_STOPWORDS = frozenset({
+    "the", "then", "and", "a", "an", "that", "moved", "move", "moves",
+    "is", "was", "it", "of", "to", "in", "at", "by", "for", "from",
+    "with", "or", "but", "on", "its", "when", "while", "also", "did",
+    "went", "going", "started", "which",
+})
+
 
 # ── Module-level helpers ──────────────────────────────────────────────
 
@@ -145,10 +153,13 @@ def _validate_robot_name(name: str) -> Optional[str]:
 
 
 def _derive_action_label(category: int, description: str) -> str:
-    """Slug-ify description and prepend category prefix."""
-    slug = _re.sub(r"[^a-zA-Z0-9]+", "_", description.lower()).strip("_")
+    """Slug-ify description, strip stopwords, cap at 32 chars."""
+    words = _re.sub(r"[^a-zA-Z0-9\s]+", " ", description.lower()).split()
+    words = [w for w in words if w not in _SLUG_STOPWORDS]
+    slug = "_".join(words)
     prefix = _CATEGORY_ACTION_PREFIX.get(category, "action")
-    return f"{prefix}_{slug}"
+    label = f"{prefix}_{slug}"
+    return label[:32].rstrip("_")
 
 
 def _input_int(prompt: str, valid_range: Optional[range] = None) -> int:
@@ -477,7 +488,7 @@ class CalibrationWizard:
                     try:
                         desc = input(
                             "  Describe what moved "
-                            "(e.g. 'front-left wheel forward'): "
+                            "(e.g. 'left wheel' or 'gripper' — keep it short): "
                         ).strip()
                     except EOFError:
                         desc = ""
@@ -511,12 +522,18 @@ class CalibrationWizard:
                 print(f"  Mapped: BCM {bcm_pin} → {action_label} "
                       f"({_CATEGORY_LABELS[choice]})")
 
-            try:
-                cont = input(
-                    "  Continue to next pin? [Y/n/s=stop]: "
-                ).strip().lower()
-            except EOFError:
-                cont = ""
+            cont = ""
+            while True:
+                try:
+                    cont = input(
+                        "  Continue to next pin? [Y/n/s=stop]: "
+                    ).strip().lower()
+                except EOFError:
+                    cont = ""
+                if cont in ("", "y", "yes", "n", "no", "s", "stop"):
+                    break
+                print("  Please enter Y to continue, N to stop here, "
+                      "or S to stop calibration.")
             if cont in ("n", "no", "s", "stop"):
                 break
 
@@ -1031,9 +1048,15 @@ class CalibrationWizard:
 
     def _pulse_servo_pin(self, bcm_pin: int,
                          servo_type: str = "continuous") -> bool:
-        """Pulse a servo pin. Returns True if pulse was sent."""
+        """Pulse a servo pin. Returns True if pulse was sent.
+
+        cleanup() is in a finally block so GPIO releases even on KeyboardInterrupt.
+        """
+        pwm = None
+        gpio_mod = None
         try:
             import RPi.GPIO as GPIO
+            gpio_mod = GPIO
             GPIO.setmode(GPIO.BCM)
             GPIO.setwarnings(False)
             GPIO.setup(bcm_pin, GPIO.OUT)
@@ -1055,11 +1078,20 @@ class CalibrationWizard:
                 time.sleep(0.3)
                 pwm.ChangeDutyCycle(7.0)  # back to 90°
                 time.sleep(0.15)
-            pwm.stop()
-            GPIO.cleanup(bcm_pin)
             return True
         except (ImportError, RuntimeError, Exception):
             return False
+        finally:
+            if pwm is not None:
+                try:
+                    pwm.stop()
+                except Exception:
+                    pass
+            if gpio_mod is not None:
+                try:
+                    gpio_mod.cleanup(bcm_pin)
+                except Exception:
+                    pass
 
     def _test_channel(self, channel: str, power: float = 0.1,
                       duration: float = 0.5,

{aether_robotics-3.4.0 → aether_robotics-3.4.2}/aether/core/navigation_engine.py

@@ -872,8 +872,9 @@ class _MotorNav:
             duty = 2.0 + (mapped / 180.0) * 10.0
             result = self.pwm_set(pin, 50, duty)
             if result.get("success"):
-                result["data"]["speed"] = speed
-                result["data"]["servo_type"] = "continuous"
+                # pwm_set returns a flat dict — annotate directly, no "data" key
+                result["speed"] = speed
+                result["servo_type"] = "continuous"
             return result
 
         # Positional servo (default): 2-12% duty cycle at 50Hz for 0-180°

{aether_robotics-3.4.0 → aether_robotics-3.4.2}/aether/core/tool_registry.py

@@ -11,6 +11,33 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Dict, List, Optional, Any
 
+# ── Continuous-servo direction helpers (used by physical_map tool closures) ──
+
+_CONTINUOUS_STOP_TERMS = frozenset({
+    "stop", "halt", "off", "neutral", "brake", "idle", "0",
+})
+_CONTINUOUS_REVERSE_TERMS = frozenset({
+    "reverse", "backward", "back", "counter", "ccw",
+    "counterclockwise", "negative",
+})
+
+
+def _infer_continuous_speed(val) -> float:
+    """Map a direction hint to continuous-servo speed (-100..+100).
+
+    0.0  = stop  (90° PWM pulse)
+    100.0 = full forward / clockwise  (180° PWM pulse)
+    -100.0 = full reverse / counter-clockwise  (0° PWM pulse)
+    """
+    if isinstance(val, (int, float)):
+        return float(max(-100.0, min(100.0, val)))
+    s = str(val).lower()
+    if any(t in s for t in _CONTINUOUS_STOP_TERMS):
+        return 0.0
+    if any(t in s for t in _CONTINUOUS_REVERSE_TERMS):
+        return -100.0
+    return 100.0  # forward / clockwise / go / start
+
 
 @dataclass
 class ToolResult:
@@ -25,6 +52,7 @@ class ToolResult:
 class BaseTool(ABC):
     """Abstract base matching AbstractAction interface."""
     name: str = ""
+    metadata: Dict = {}  # overridden by DynamicTool for physical_map entries
 
     @abstractmethod
     def execute(self, params: Dict) -> ToolResult:
@@ -751,10 +779,12 @@ class DynamicTool(BaseTool):
     and NavigationEngine actions into the BaseTool/ToolResult interface.
     """
 
-    def __init__(self, name: str, fn, desc: str = ""):
+    def __init__(self, name: str, fn, desc: str = "",
+                 metadata: Optional[Dict] = None):
         self.name = name
         self._fn = fn
         self._desc = desc or f"Dynamic tool: {name}"
+        self.metadata: Dict = metadata or {}
 
     def description(self) -> str:
         return self._desc
@@ -973,6 +1003,59 @@ def register_built_tools(registry: "ToolRegistry",
                 f"Navigation action: {action} (level {nav_engine.level})"))
             count += 1
 
+    # -- Physical map tools ---------------------------------------------------
+    # Register one real callable tool per physical_map entry.  The LLM emits
+    # the action label; this makes it actually executable against the right pin.
+    physical_map = (manifest or {}).get("physical_map", {})
+    if physical_map and nav_engine is not None:
+        for bucket in ("wheels", "arms", "grippers", "servos", "dc_motors"):
+            for entry in physical_map.get(bucket, []):
+                label = entry.get("action")
+                bcm   = entry.get("bcm")
+                ptype = entry.get("pwm_type", "servo_positional")
+                desc  = entry.get("description", label or "")
+
+                if not label or bcm is None:
+                    continue
+                if registry.get(label) is not None:
+                    continue  # already registered (e.g. from prior iteration)
+
+                def _make_physical_fn(pin, pwm_type):
+                    def _fn(**kwargs):
+                        if pwm_type == "servo_continuous":
+                            # Accept direction/speed/angle — any key the LLM uses
+                            hint = kwargs.get(
+                                "direction",
+                                kwargs.get("speed",
+                                kwargs.get("angle", "forward")))
+                            speed = _infer_continuous_speed(hint)
+                            return registry.execute(
+                                "servo_set",
+                                {"pin": pin, "angle": speed,
+                                 "servo_type": "continuous"})
+                        elif pwm_type == "servo_positional":
+                            angle = float(kwargs.get("angle", 90))
+                            return registry.execute(
+                                "servo_set",
+                                {"pin": pin, "angle": angle,
+                                 "servo_type": "positional"})
+                        else:  # dc
+                            spd = float(kwargs.get("speed", 50))
+                            return registry.execute(
+                                "motor_forward",
+                                {"left_pin": pin, "right_pin": pin,
+                                 "speed": spd})
+                    return _fn
+
+                registry.register(DynamicTool(
+                    label,
+                    _make_physical_fn(bcm, ptype),
+                    f"{desc} (BCM {bcm}, {ptype})",
+                    metadata={"bcm": bcm, "pwm_type": ptype,
+                              "description": desc},
+                ))
+                count += 1
+
     print(f"  [ToolRegistry] Registered {count} tools from ToolBuilder")
     return count
 

{aether_robotics-3.4.0 → aether_robotics-3.4.2/aether_robotics.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aether-robotics
-Version: 3.4.0
+Version: 3.4.2
 Summary: Autonomous multi-agent robotics system with DRL-First Hybrid FDIR
 Author: Chahel Paatur
 License: MIT
@@ -45,7 +45,7 @@ Dynamic: license-file
   <img src="https://img.shields.io/badge/license-MIT-green?style=flat-square" alt="License: MIT">
   <img src="https://img.shields.io/github/stars/ChahelPaatur/AETHER?style=flat-square" alt="GitHub Stars">
   <img src="https://img.shields.io/badge/platform-Linux%20%7C%20macOS%20%7C%20Raspberry%20Pi%20%7C%20Jetson-lightgrey?style=flat-square" alt="Platforms">
-  <img src="https://img.shields.io/badge/version-3.3.3-red?style=flat-square" alt="v3.3.3">
+  <img src="https://img.shields.io/badge/version-3.4.0-red?style=flat-square" alt="v3.4.0">
 </p>
 
 ```

{aether_robotics-3.4.0 → aether_robotics-3.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aether-robotics"
-version = "3.4.0"
+version = "3.4.2"
 description = "Autonomous multi-agent robotics system with DRL-First Hybrid FDIR"
 readme = "README.md"
 license = {text = "MIT"}

{aether_robotics-3.4.0 → aether_robotics-3.4.2}/tests/test_calibration.py

@@ -13,6 +13,7 @@ from aether.core.calibration import (
     CalibrationWizard,
     load_calibration,
     _expected_direction,
+    _derive_action_label,
     GROUND_VEHICLE,
     AERIAL_VEHICLE,
     ROBOTIC_ARM,
@@ -415,3 +416,202 @@ class TestFullAutoRun:
 
         assert profile["calibrated"] is True
         assert profile["robot_type"] == AERIAL_VEHICLE
+
+
+class TestActionLabelSlugifier:
+    """Bug 4: _derive_action_label stopwords + 32-char cap."""
+
+    def test_strips_stopwords(self):
+        label = _derive_action_label(1, "the left wheel moved forward")
+        assert "the" not in label
+        assert "moved" not in label
+        assert "left" in label
+        assert "forward" in label
+
+    def test_caps_at_32_chars(self):
+        long_desc = "left wheel clockwise then counter clockwise slowly"
+        label = _derive_action_label(5, long_desc)
+        assert len(label) <= 32
+
+    def test_correct_prefix(self):
+        assert _derive_action_label(1, "left wheel").startswith("drive_")
+        assert _derive_action_label(3, "gripper").startswith("gripper_")
+        assert _derive_action_label(5, "left wheel").startswith("servo_cont_")
+        assert _derive_action_label(6, "motor A").startswith("motor_")
+
+    def test_no_trailing_underscore(self):
+        label = _derive_action_label(1, "the the the")
+        assert not label.endswith("_")
+
+
+class TestPhysicalMapToolRegistration:
+    """Bug 1: physical_map entries become callable tools in ToolRegistry."""
+
+    _PHYSICAL_MAP = {
+        "wheels": [{"bcm": 17, "description": "left wheel forward",
+                    "action": "drive_left_wheel_forward",
+                    "pwm_type": "servo_positional"}],
+        "servos": [{"bcm": 22, "description": "left wheel",
+                    "action": "servo_cont_left_wheel",
+                    "pwm_type": "servo_continuous"}],
+    }
+
+    def test_physical_map_labels_registered(self):
+        """register_built_tools adds a DynamicTool for each physical_map entry."""
+        from aether.core.tool_registry import (
+            ToolRegistry, register_built_tools, _infer_continuous_speed,
+        )
+
+        registry = ToolRegistry()
+        manifest = {"physical_map": self._PHYSICAL_MAP}
+
+        # nav_engine stub: just needs to not be None and have available_actions()
+        class _FakeNav:
+            level = 2
+            def available_actions(self): return []
+            def execute(self, act, params): return {"success": True}
+
+        register_built_tools(registry, {}, _FakeNav(), manifest=manifest)
+
+        assert registry.get("drive_left_wheel_forward") is not None
+        assert registry.get("servo_cont_left_wheel") is not None
+
+    def test_infer_continuous_speed_forward(self):
+        from aether.core.tool_registry import _infer_continuous_speed
+        assert _infer_continuous_speed("forward") == 100.0
+        assert _infer_continuous_speed("go") == 100.0
+        assert _infer_continuous_speed("clockwise") == 100.0
+
+    def test_infer_continuous_speed_stop(self):
+        from aether.core.tool_registry import _infer_continuous_speed
+        assert _infer_continuous_speed("stop") == 0.0
+        assert _infer_continuous_speed("halt") == 0.0
+        assert _infer_continuous_speed(0) == 0.0
+
+    def test_infer_continuous_speed_reverse(self):
+        from aether.core.tool_registry import _infer_continuous_speed
+        assert _infer_continuous_speed("reverse") == -100.0
+        assert _infer_continuous_speed("backward") == -100.0
+        assert _infer_continuous_speed(-50) == -50.0
+
+    def test_physical_map_tool_has_metadata(self):
+        """Bug B: registered physical_map DynamicTool carries bcm + pwm_type metadata."""
+        from aether.core.tool_registry import ToolRegistry, register_built_tools
+
+        registry = ToolRegistry()
+        manifest = {"physical_map": self._PHYSICAL_MAP}
+
+        class _FakeNav:
+            level = 2
+            def available_actions(self): return []
+            def execute(self, act, params): return {"success": True}
+
+        register_built_tools(registry, {}, _FakeNav(), manifest=manifest)
+
+        tool = registry.get("drive_left_wheel_forward")
+        assert tool is not None
+        assert tool.metadata.get("bcm") == 17
+        assert tool.metadata.get("pwm_type") == "servo_positional"
+
+        tool_cont = registry.get("servo_cont_left_wheel")
+        assert tool_cont is not None
+        assert tool_cont.metadata.get("bcm") == 22
+        assert tool_cont.metadata.get("pwm_type") == "servo_continuous"
+
+
+class TestBugFixes342:
+    """3.4.2 regression tests: servo_set flat dict, correction pin override,
+    pulse_servo_pin cleanup on interrupt."""
+
+    def test_servo_set_continuous_no_data_keyerror(self):
+        """Bug A: servo_set continuous result must not raise KeyError on 'data'."""
+        # Simulate the _MotorNav.servo_set logic without real GPIO
+        # pwm_set returns flat dict — no "data" key
+        result = {"pin": 17, "frequency": 50, "duty_cycle": 12.0,
+                  "success": True, "error": ""}
+        # Apply the fixed logic
+        if result.get("success"):
+            result["speed"] = 100.0
+            result["servo_type"] = "continuous"
+        assert "speed" in result
+        assert result["servo_type"] == "continuous"
+        assert "data" not in result  # old bug: this would have been needed
+
+    def test_correction_agent_pin_override(self):
+        """Bug B belt-and-suspenders: CorrectionAgent overrides wrong pin from LLM."""
+        # Simulate the override logic with tool_metadata bcm=17 and LLM proposing pin=18
+        tool_metadata = {"bcm": 17, "pwm_type": "servo_continuous"}
+        corr_tool = "servo_set"
+        corr_inputs = {"pin": 18, "angle": 100, "servo_type": "continuous"}
+
+        _PIN_FALLBACK_TOOLS = {"servo_set", "motor_forward", "motor_turn"}
+        if tool_metadata and corr_tool in _PIN_FALLBACK_TOOLS:
+            meta_bcm = tool_metadata.get("bcm")
+            if meta_bcm is not None:
+                corr_inputs = dict(corr_inputs)
+                pin_keys = (["pin"] if corr_tool == "servo_set"
+                            else ["left_pin", "right_pin"])
+                for pk in pin_keys:
+                    if corr_inputs.get(pk) != meta_bcm:
+                        corr_inputs[pk] = meta_bcm
+
+        assert corr_inputs["pin"] == 17  # overridden from 18
+
+    def test_correction_agent_pin_override_missing_pin(self):
+        """Bug B: pin added when absent from correction inputs."""
+        tool_metadata = {"bcm": 22, "pwm_type": "servo_positional"}
+        corr_tool = "servo_set"
+        corr_inputs = {"angle": 90, "servo_type": "positional"}  # no pin
+
+        _PIN_FALLBACK_TOOLS = {"servo_set", "motor_forward", "motor_turn"}
+        if tool_metadata and corr_tool in _PIN_FALLBACK_TOOLS:
+            meta_bcm = tool_metadata.get("bcm")
+            if meta_bcm is not None:
+                corr_inputs = dict(corr_inputs)
+                pin_keys = ["pin"]
+                for pk in pin_keys:
+                    if corr_inputs.get(pk) != meta_bcm:
+                        corr_inputs[pk] = meta_bcm
+
+        assert corr_inputs["pin"] == 22
+
+    def test_pulse_servo_pin_finally_on_simulated_interrupt(self):
+        """Bug C: _pulse_servo_pin cleanup runs even when GPIO raises."""
+        cleanup_called = []
+
+        class _FakeGPIO:
+            BCM = 11
+            OUT = 0
+            @staticmethod
+            def setmode(m): pass
+            @staticmethod
+            def setwarnings(w): pass
+            @staticmethod
+            def setup(p, m): pass
+            class PWM:
+                def __init__(self, pin, freq): pass
+                def start(self, dc): pass
+                def ChangeDutyCycle(self, dc):
+                    raise RuntimeError("simulated mid-pulse error")
+                def stop(self): cleanup_called.append("pwm.stop")
+            @staticmethod
+            def cleanup(pin): cleanup_called.append(f"cleanup:{pin}")
+
+        import sys
+        sys.modules["RPi"] = type(sys)("RPi")
+        sys.modules["RPi.GPIO"] = _FakeGPIO
+        try:
+            wiz = CalibrationWizard(
+                {"hardware": {"gpio": {"available": False},
+                              "mavlink": {"available": False}}},
+                configs_dir="/tmp",
+                auto_mode=True,
+            )
+            result = wiz._pulse_servo_pin(17, "positional")
+        finally:
+            del sys.modules["RPi.GPIO"]
+            del sys.modules["RPi"]
+
+        # Whether the pulse succeeded or not, cleanup must have been attempted
+        assert any("cleanup" in str(c) or "stop" in str(c)
+                   for c in cleanup_called)

aether_robotics-3.4.0/VERSION

@@ -1 +0,0 @@
-3.3.9