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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aether-robotics
-Version: 3.4.2
+Version: 3.4.3
 Summary: Autonomous multi-agent robotics system with DRL-First Hybrid FDIR
 Author: Chahel Paatur
 License: MIT

aether_robotics-3.4.3/VERSION

@@ -0,0 +1 @@
+3.4.3

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

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

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

@@ -134,8 +134,12 @@ _CATEGORY_ACTION_PREFIX: Dict[int, str] = {
 # 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",
+    "is", "was", "it", "of", "to",
+    # "in" and "on" intentionally excluded: they appear in directional phrases
+    # like "in front", "on the left", "on top" and must survive slugification.
+    "at", "by", "for", "from",
+    "with", "or", "but",
+    "its", "when", "while", "also", "did",
     "went", "going", "started", "which",
 })
 

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

@@ -858,10 +858,17 @@ class _MotorNav:
         return _ok({"action": "stop"})
 
     def servo_set(self, pin: int, angle: float,
-                  servo_type: str = "positional") -> Dict:
+                  servo_type: str = "positional",
+                  duty_cycle: Optional[float] = None) -> Dict:
         if self._gpio is None:
             return _err("GPIO not available")
 
+        # If an explicit duty_cycle is supplied, use it directly and skip the
+        # angle→duty formula.  This lets CorrectionAgent override the output
+        # without having to reverse-engineer the mapping.
+        if duty_cycle is not None:
+            return self.pwm_set(pin, 50, float(duty_cycle))
+
         if servo_type == "continuous":
             # Continuous-rotation servo: interpret angle as speed -100..+100
             # 0 → stop (90°), positive → forward, negative → reverse
@@ -1682,7 +1689,8 @@ class NavigationEngine:
                 "servo_set": lambda: self._motors.servo_set(
                     params.get("pin") or self._default_servo_pin(),
                     params.get("angle", 90),
-                    params.get("servo_type") or self._default_servo_type()),
+                    params.get("servo_type") or self._default_servo_type(),
+                    duty_cycle=params.get("duty_cycle")),
                 "navigate_to_color": lambda: self._motors.navigate_to_color(
                     params.get("color", params.get("class_name", "red")),
                     lp, rp, sp, params.get("timeout", 30)),

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

@@ -1023,18 +1023,52 @@ def register_built_tools(registry: "ToolRegistry",
                 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")))
+                            # Resolve direction from whichever kwarg the LLM uses.
+                            # Priority: direction/speed > angle > position > default.
+                            if "direction" in kwargs or "speed" in kwargs:
+                                hint = kwargs.get("direction") or kwargs.get("speed")
+                            elif "angle" in kwargs:
+                                hint = kwargs["angle"]
+                            elif "position" in kwargs:
+                                # "position" is a positional-servo idiom with no
+                                # meaning on a continuous servo.  position=90 is the
+                                # center/neutral default — treat it as forward intent
+                                # because stopping requires an explicit stop/halt/neutral.
+                                # TODO: thread objective text into the closure so that
+                                # "stop" + position=90 maps to neutral (0.0) while
+                                # "move" + position=90 maps to forward (100.0).
+                                pos = kwargs["position"]
+                                hint = "forward" if float(pos) == 90.0 else pos
+                            else:
+                                # No direction hint at all — default to forward.
+                                # Stopping requires explicit stop/halt/neutral intent.
+                                hint = "forward"
+
                             speed = _infer_continuous_speed(hint)
-                            return registry.execute(
+                            result = registry.execute(
                                 "servo_set",
                                 {"pin": pin, "angle": speed,
                                  "servo_type": "continuous"})
+
+                            # Optional timed run: spin for N seconds then neutral.
+                            duration = kwargs.get("duration")
+                            if duration is not None and result.success:
+                                try:
+                                    time.sleep(float(duration))
+                                except (ValueError, TypeError):
+                                    pass
+                                registry.execute(
+                                    "servo_set",
+                                    {"pin": pin, "angle": 0.0,
+                                     "servo_type": "continuous"})
+
+                            return result
+
                         elif pwm_type == "servo_positional":
-                            angle = float(kwargs.get("angle", 90))
+                            # Accept both "angle" and "position" — LLM uses either
+                            angle = float(
+                                kwargs.get("angle",
+                                kwargs.get("position", 90)))
                             return registry.execute(
                                 "servo_set",
                                 {"pin": pin, "angle": angle,

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aether-robotics
-Version: 3.4.2
+Version: 3.4.3
 Summary: Autonomous multi-agent robotics system with DRL-First Hybrid FDIR
 Author: Chahel Paatur
 License: MIT

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

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

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

@@ -615,3 +615,92 @@ class TestBugFixes342:
         # 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)
+
+
+class TestBugFixes343:
+    """3.4.3 regression tests: continuous-servo default-forward, duty_cycle
+    bypass, stopword preservation of directional words."""
+
+    # ── Helpers ──────────────────────────────────────────────────────────
+
+    def _make_registry_and_tool(self, pwm_type):
+        """Build a minimal registry with one physical_map tool and a mock
+        servo_set that records the params it was called with."""
+        from aether.core.tool_registry import (
+            ToolRegistry, register_built_tools, DynamicTool,
+        )
+
+        calls = []
+
+        registry = ToolRegistry()
+
+        def _fake_servo_set(**params):
+            calls.append(dict(params))
+            return {"success": True, "pin": params.get("pin"),
+                    "angle": params.get("angle"),
+                    "servo_type": params.get("servo_type")}
+
+        registry.register(DynamicTool("servo_set", _fake_servo_set,
+                                      "fake servo_set"))
+
+        physical_map = {
+            "servos": [{"bcm": 17, "description": "left wheel",
+                        "action": "servo_test_tool",
+                        "pwm_type": pwm_type}],
+        }
+
+        class _FakeNav:
+            level = 2
+            def available_actions(self): return ["servo_set"]
+            def execute(self, act, params): return {"success": True}
+
+        register_built_tools(registry, {}, _FakeNav(),
+                             manifest={"physical_map": physical_map})
+
+        return registry, calls
+
+    # ── Bug D: continuous defaults to forward ─────────────────────────
+
+    def test_continuous_no_hint_defaults_to_forward(self):
+        """servo_continuous with no direction kwarg must spin forward (speed>0)."""
+        registry, calls = self._make_registry_and_tool("servo_continuous")
+        registry.execute("servo_test_tool", {})  # no hint at all
+        assert calls, "servo_set was never called"
+        # angle passed to servo_set should be > 0 (forward), not 0.0 (stop)
+        assert calls[0]["angle"] > 0, (
+            f"Expected forward speed > 0, got {calls[0]['angle']}")
+
+    def test_continuous_position_90_treated_as_forward(self):
+        """position=90 on a continuous servo must map to forward, not neutral."""
+        registry, calls = self._make_registry_and_tool("servo_continuous")
+        registry.execute("servo_test_tool", {"position": 90})
+        assert calls, "servo_set was never called"
+        assert calls[0]["angle"] > 0, (
+            f"Expected forward (>0), got angle={calls[0]['angle']}")
+
+    def test_continuous_explicit_stop_still_stops(self):
+        """An explicit 'stop' direction must still produce neutral (angle=0.0)."""
+        registry, calls = self._make_registry_and_tool("servo_continuous")
+        registry.execute("servo_test_tool", {"direction": "stop"})
+        assert calls, "servo_set was never called"
+        assert calls[0]["angle"] == 0.0, (
+            f"Expected stop (0.0), got angle={calls[0]['angle']}")
+
+    # ── Bug F: "in" and "on" survive slugification ────────────────────
+
+    def test_direction_words_in_and_on_not_stripped(self):
+        """'in front' and 'on the left' must keep 'in', 'on', 'front', 'left'."""
+        from aether.core.calibration import _derive_action_label
+        label = _derive_action_label(2, "in front on the left")
+        assert "in" in label, f"'in' was stripped from label: {label}"
+        assert "front" in label, f"'front' was stripped from label: {label}"
+        # "on" should also survive
+        assert "on" in label, f"'on' was stripped from label: {label}"
+
+    def test_clockwise_and_counter_preserved(self):
+        """'clockwise' and 'counter' must survive slugification."""
+        from aether.core.calibration import _derive_action_label
+        label = _derive_action_label(5, "left wheel clockwise")
+        assert "left" in label, f"'left' stripped: {label}"
+        assert "clockwise" in label, f"'clockwise' stripped: {label}"
+        assert "wheel" in label, f"'wheel' stripped: {label}"

aether_robotics-3.4.2/VERSION

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