aether-robotics 3.7.2__tar.gz → 3.7.4__tar.gz

{aether_robotics-3.7.2/aether_robotics.egg-info → aether_robotics-3.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aether-robotics
-Version: 3.7.2
+Version: 3.7.4
 Summary: Autonomous multi-agent robotics system with DRL-First Hybrid FDIR
 Author: Chahel Paatur
 License: MIT
@@ -57,7 +57,7 @@ Dynamic: license-file
     ████████████████████████████████
 ```
 
-# AETHER v3.7.2 — Autonomous Robotics Operating System
+# AETHER v3.7.4 — Autonomous Robotics Operating System
 
 > AETHER is the autonomous operating system for robots. Plug in and talk to your robot in plain English and ask it to do anything you want.
 

{aether_robotics-3.7.2 → aether_robotics-3.7.4}/README.md

@@ -16,7 +16,7 @@
     ████████████████████████████████
 ```
 
-# AETHER v3.7.2 — Autonomous Robotics Operating System
+# AETHER v3.7.4 — Autonomous Robotics Operating System
 
 > AETHER is the autonomous operating system for robots. Plug in and talk to your robot in plain English and ask it to do anything you want.
 

aether_robotics-3.7.4/VERSION

@@ -0,0 +1 @@
+3.7.4

{aether_robotics-3.7.2 → aether_robotics-3.7.4}/aether/__init__.py

@@ -1,2 +1,2 @@
-__version__ = "3.7.2"
+__version__ = "3.7.4"
 __author__ = "Chahel Paatur"

{aether_robotics-3.7.2 → aether_robotics-3.7.4}/aether/adapters/__init__.py

@@ -136,6 +136,51 @@ def _build_vendor_lib_list() -> List[str]:
     return present
 
 
+def detect_adapter(manifest: Dict, i2c_devices: Optional[List] = None,
+                   include_user_dir: bool = True) -> Optional[str]:
+    """Detection-only: would any adapter claim this hardware? No registration.
+
+    Mirrors the match logic of load_tier1 (signature_matches on each Tier 1
+    adapter) plus the presence of any user-dir generated/guided adapter,
+    WITHOUT calling register() or touching the registry. Used at boot to
+    decide whether the interactive calibration wizard should run: the
+    resolver's verdict must be known BEFORE the (blocking) wizard fires,
+    otherwise the wizard preempts the resolver on a fresh profile.
+
+    Returns the adapter_id that would match, or None.
+    """
+    i2c_devices = i2c_devices or (
+        manifest.get("hardware", {}).get("i2c", {}).get("devices", []))
+    vendor_libs = _build_vendor_lib_list()
+
+    for path in sorted(glob.glob(os.path.join(_ADAPTER_DIR, "*.py"))):
+        basename = os.path.basename(path)
+        if basename.startswith("_") or basename in ("__init__.py",
+                "base_adapter.py", "rover_adapter.py",
+                "drone_adapter.py", "universal_adapter.py"):
+            continue
+        mod_name = f"aether.adapters._detect_{basename[:-3]}"
+        try:
+            spec = importlib.util.spec_from_file_location(mod_name, path)
+            mod = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(mod)
+            if mod.signature_matches(manifest, i2c_devices, vendor_libs):
+                return basename[:-3]
+        except Exception:
+            continue  # a broken adapter never blocks detection
+
+    # A user-dir adapter (from a previous Tier 2/3 run) is loaded
+    # unconditionally by load_user_adapters, so its mere presence means the
+    # robot is already configured — count it as a match for the wizard gate.
+    if include_user_dir and os.path.isdir(_USER_ADAPTER_DIR):
+        for fname in sorted(os.listdir(_USER_ADAPTER_DIR)):
+            if fname.endswith(".py") and (
+                    fname.startswith("generated_") or fname.startswith("guided_")):
+                return fname.replace(".py", "")
+
+    return None
+
+
 def load_tier1(manifest: Dict, registry, i2c_devices: Optional[List] = None) -> Optional[str]:
     """Iterate pre-built adapters. First match wins; returns adapter_id or None.
 

{aether_robotics-3.7.2 → aether_robotics-3.7.4}/aether/app.py

@@ -401,6 +401,22 @@ def _print_fault_alert(fault_type: str, details: str) -> None:
     print(f"  !! FAULT: {fault_type} — {details}")
 
 
+def _should_run_autocal_wizard(pre_adapter_id, calibration_profile,
+                               needs_calibration: bool) -> bool:
+    """Auto-detect (non --calibrate) calibration-wizard gate.
+
+    The wizard fires only when NO adapter claims the hardware AND there is
+    no existing calibration profile AND the wizard reports new hardware.
+    An adapter match means the robot is already configured — the resolver
+    will build the genome from the adapter, so the wizard must be skipped.
+    """
+    if pre_adapter_id is not None:
+        return False
+    if calibration_profile is not None:
+        return False
+    return bool(needs_calibration)
+
+
 def _adapter_resolver(manifest, registry, genome,
                        calibrating: bool = False,
                        no_auto: bool = False):
@@ -592,16 +608,37 @@ def run_agent(args) -> None:
         auto_mode=auto_cal,
         force_remap=recalibrate,
     )
+
+    # Adapter-resolver verdict BEFORE the (blocking, interactive) wizard.
+    # If a pre-built or previously-generated adapter claims this hardware,
+    # the robot is already configured and the auto-detect wizard must be
+    # skipped — otherwise it preempts the resolver whenever no calibration
+    # profile is present. This is a side-effect-free detection pass; the
+    # full resolver (which registers the tools) still runs below at the
+    # Auto-Adapter step and prints the [ADAPTER] match line.
+    from aether.adapters import detect_adapter
+    no_auto = getattr(args, "no_auto_adapter", False)
+    pre_adapter_id = None
+    if not (calibrate or recalibrate):
+        pre_adapter_id = detect_adapter(
+            discovery.manifest, include_user_dir=(not no_auto))
+        if pre_adapter_id:
+            _print_activity("ADAPTER",
+                f"Detected '{pre_adapter_id}' — using adapter, skipping "
+                f"calibration wizard")
+
     if calibrate or recalibrate:
         if recalibrate or wizard.needs_calibration(force=True):
             calibration_profile = wizard.run()
     else:
-        # Auto-detect: load existing or prompt if new hardware found
+        # Auto-detect: load existing profile, else run the wizard ONLY if no
+        # adapter matched and new hardware is present.
         calibration_profile = load_calibration()
         if calibration_profile:
             _print_activity("CAL", f"Loaded: {calibration_profile['robot_name']} "
                             f"({calibration_profile['robot_type']})")
-        elif wizard.needs_calibration():
+        elif _should_run_autocal_wizard(pre_adapter_id, calibration_profile,
+                                        wizard.needs_calibration()):
             _print_activity("CAL", "New hardware detected — running calibration wizard")
             calibration_profile = wizard.run()
 
@@ -710,7 +747,7 @@ def run_agent(args) -> None:
         _print_activity("MAVLINK", f"Registered {n_mav} MAVLink capability tools on {mav_port}")
 
     # ── Auto-Adapter System (Tier 1 / Tier 2 / Tier 3) ───────────────
-    no_auto = getattr(args, "no_auto_adapter", False)
+    # no_auto already resolved above (before the wizard gate).
     adapter_id, adapter_tools = _adapter_resolver(
         manifest, registry, genome,
         calibrating=(calibrate or recalibrate),

{aether_robotics-3.7.2 → aether_robotics-3.7.4}/aether/core/tool_discovery.py

@@ -97,13 +97,49 @@ def _probe_gpio_gpiozero() -> Tuple[bool, Dict]:
 
 
 def _probe_i2c() -> Tuple[bool, Dict]:
-    """Try board + busio for I2C (Adafruit Blinka)."""
+    """Enumerate I2C devices on bus 1 so adapter signature_matches can
+    detect HATs by address (e.g. SunFounder Robot HAT at 0x14).
+
+    smbus2 (shipped in the `pi` install extra) is the authoritative
+    enumerator: opening SMBus(1) proves the kernel I2C bus is enabled and
+    the user has permission, and read_byte() ACK-probes each address.
+    This replaces the old Blinka-only check, which required board+busio
+    and so reported "not detected" on real Pi HATs that work fine over
+    smbus2.
+
+    Returns (True, {"type", "available": True, "bus": 1, "devices": [...]})
+    on success, or (False, {"available": False, "devices": []}) on any
+    failure. The "devices" field is ALWAYS a list, never None. The whole
+    body is wrapped so a bug here can never crash boot.
+    """
     try:
-        import board  # noqa: F401
-        import busio  # noqa: F401
-        return True, {"type": "blinka_i2c"}
-    except (ImportError, RuntimeError, NotImplementedError):
-        return False, {"detail": "board/busio not available"}
+        try:
+            import smbus2
+        except ImportError:
+            # No enumerator available — report I2C absent rather than
+            # crash. (Blinka was the old path; smbus2 is required for the
+            # actual device scan, so its absence means no enumeration.)
+            return False, {"available": False, "devices": []}
+
+        bus = smbus2.SMBus(1)
+        devices: List[int] = []
+        try:
+            for addr in range(0x03, 0x78):
+                try:
+                    bus.read_byte(addr)
+                    devices.append(addr)
+                except OSError:
+                    pass  # no device ACKed at this address
+        finally:
+            bus.close()
+
+        print(f"  [I2C] Scanned bus 1: found {len(devices)} device(s): "
+              f"{[hex(d) for d in devices]}")
+        return True, {"type": "smbus2_i2c", "available": True,
+                      "bus": 1, "devices": devices}
+    except Exception:
+        # No /dev/i2c-1, permission error, or any unexpected failure.
+        return False, {"available": False, "devices": []}
 
 
 def _probe_mavlink_serial() -> Tuple[bool, Dict]:
@@ -1203,6 +1239,14 @@ class ToolDiscovery:
                 if key == "oled":
                     iface = info.get("interface", "spi").upper()
                     detail = f"{hw_type} {resolution} {iface}"
+                if key == "i2c":
+                    devs = info.get("devices", [])
+                    bus = info.get("bus", 1)
+                    if devs:
+                        addrs = ", ".join(hex(d) for d in devs)
+                        detail = f"bus {bus}, {len(devs)} device(s) at {addrs}"
+                    else:
+                        detail = f"bus {bus}, no devices found"
             else:
                 if key == "oled":
                     if info.get("spi_not_enabled"):

{aether_robotics-3.7.2 → aether_robotics-3.7.4/aether_robotics.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aether-robotics
-Version: 3.7.2
+Version: 3.7.4
 Summary: Autonomous multi-agent robotics system with DRL-First Hybrid FDIR
 Author: Chahel Paatur
 License: MIT
@@ -57,7 +57,7 @@ Dynamic: license-file
     ████████████████████████████████
 ```
 
-# AETHER v3.7.2 — Autonomous Robotics Operating System
+# AETHER v3.7.4 — Autonomous Robotics Operating System
 
 > AETHER is the autonomous operating system for robots. Plug in and talk to your robot in plain English and ask it to do anything you want.
 

{aether_robotics-3.7.2 → aether_robotics-3.7.4}/aether_robotics.egg-info/SOURCES.txt

@@ -84,6 +84,7 @@ configs/rover_v1.json
 context/aether_definitions.txt
 tests/test_auto_adapter.py
 tests/test_auto_updater.py
+tests/test_boot_resolver_flow.py
 tests/test_calibration.py
 tests/test_calibration_unit.py
 tests/test_chaos.py

{aether_robotics-3.7.2 → aether_robotics-3.7.4}/pyproject.toml

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

aether_robotics-3.7.4/tests/test_boot_resolver_flow.py

@@ -0,0 +1,125 @@
+"""Regression tests for the v3.7.4 boot-flow fix.
+
+Bug: the calibration wizard's auto-detect branch ran wizard.run() before
+the adapter resolver was reached, so on a fresh profile (no robot.json /
+no calibrated_*.json) the wizard preempted the resolver entirely — the
+[ADAPTER] match line never printed and a known HAT (e.g. SunFounder
+PiCar-X at I2C 0x14) was never auto-configured.
+
+Fix: a side-effect-free detect_adapter() pass runs BEFORE the wizard, and
+_should_run_autocal_wizard() skips the wizard whenever an adapter claims
+the hardware. These tests pin both halves.
+"""
+import importlib.machinery
+import os
+import sys
+import tempfile
+from types import ModuleType
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from aether.adapters import detect_adapter
+from aether.app import _should_run_autocal_wizard
+
+
+def _manifest(i2c_devices=None, gpio=False):
+    return {
+        "hardware": {
+            "gpio": {"available": gpio},
+            "i2c": {"available": bool(i2c_devices),
+                    "devices": i2c_devices or []},
+            "mavlink": {},
+        }
+    }
+
+
+# ── detect_adapter: the resolver verdict that gates the wizard ─────────
+
+def test_resolver_runs_when_no_calibration_profile():
+    """Detection is independent of calibration state — it runs and returns
+    a verdict whether or not a profile exists. (No profile is read here.)"""
+    # PiCar-X HAT present → a Tier 1 adapter must claim it...
+    assert detect_adapter(_manifest(i2c_devices=[0x14])) is not None
+    # ...and bare hardware with no matching HAT yields no adapter, so the
+    # caller (boot flow) will fall through to the wizard.
+    with patch("aether.adapters._build_vendor_lib_list", return_value=[]):
+        verdict = detect_adapter(_manifest(gpio=False), include_user_dir=False)
+    assert verdict is None
+
+
+def test_resolver_matches_sunfounder_picarx_with_i2c_0x14():
+    """The SunFounder Robot HAT at 0x14 must be detected as picarx."""
+    with patch("aether.adapters._build_vendor_lib_list", return_value=[]):
+        adapter_id = detect_adapter(_manifest(i2c_devices=[0x14]),
+                                    include_user_dir=False)
+    assert adapter_id == "sunfounder_picarx"
+
+
+def test_resolver_matches_user_dir_adapter_when_picarx_lib_present():
+    """Brief req #6 case 2: a generated user-dir adapter present AND picarx
+    importable → detection returns a match (non-None) so the wizard is
+    skipped. With picarx importable the Tier 1 sunfounder adapter claims it
+    first; that still satisfies the contract (an adapter loads, no wizard)."""
+    with tempfile.TemporaryDirectory() as udir:
+        with open(os.path.join(udir, "generated_picarx_test.py"), "w") as f:
+            f.write("# generated adapter stub\n")
+        fake_picarx = ModuleType("picarx")
+        fake_picarx.__spec__ = importlib.machinery.ModuleSpec("picarx", loader=None)
+        fake_picarx.Picarx = MagicMock()
+        with patch("aether.adapters._USER_ADAPTER_DIR", udir), \
+             patch.dict(sys.modules, {"picarx": fake_picarx}):
+            adapter_id = detect_adapter(_manifest(), include_user_dir=True)
+    assert adapter_id is not None  # an adapter claims it → wizard skipped
+
+
+def test_resolver_matches_user_dir_adapter_when_no_tier1_match():
+    """User-dir path in isolation: no Tier 1 adapter matches (no picarx, no
+    i2c, no vendor libs) → the generated user-dir adapter is the match."""
+    with tempfile.TemporaryDirectory() as udir:
+        with open(os.path.join(udir, "generated_picarx_test.py"), "w") as f:
+            f.write("# generated adapter stub\n")
+        with patch("aether.adapters._USER_ADAPTER_DIR", udir), \
+             patch("aether.adapters._build_vendor_lib_list", return_value=[]):
+            adapter_id = detect_adapter(_manifest(), include_user_dir=True)
+    assert adapter_id == "generated_picarx_test"
+
+
+def test_user_dir_ignored_when_no_auto():
+    """include_user_dir=False (i.e. --no-auto-adapter) must not count
+    user-dir adapters toward the wizard-skip decision."""
+    with tempfile.TemporaryDirectory() as udir:
+        with open(os.path.join(udir, "generated_picarx_test.py"), "w") as f:
+            f.write("# stub\n")
+        with patch("aether.adapters._USER_ADAPTER_DIR", udir), \
+             patch("aether.adapters._build_vendor_lib_list", return_value=[]):
+            adapter_id = detect_adapter(_manifest(), include_user_dir=False)
+    assert adapter_id is None
+
+
+# ── _should_run_autocal_wizard: the wizard gate ────────────────────────
+
+def test_calibration_wizard_skipped_when_adapter_matches():
+    """Adapter matched → wizard must NOT fire, even with new hardware and
+    no profile."""
+    assert _should_run_autocal_wizard(
+        "sunfounder_picarx", None, needs_calibration=True) is False
+
+
+def test_calibration_wizard_runs_when_no_adapter_and_no_profile():
+    """No adapter, no profile, new hardware → wizard fires (the today path)."""
+    assert _should_run_autocal_wizard(
+        None, None, needs_calibration=True) is True
+
+
+def test_calibration_wizard_skipped_when_profile_present():
+    """No adapter but an existing profile → load profile, no wizard."""
+    profile = {"robot_name": "rover", "robot_type": "differential_drive"}
+    assert _should_run_autocal_wizard(
+        None, profile, needs_calibration=True) is False
+
+
+def test_calibration_wizard_skipped_when_no_new_hardware():
+    """No adapter, no profile, but wizard reports no new hardware → no wizard."""
+    assert _should_run_autocal_wizard(
+        None, None, needs_calibration=False) is False

aether_robotics-3.7.4/tests/test_tool_discovery.py

@@ -0,0 +1,133 @@
+"""Tests for ToolDiscovery: platform detection, manifest structure."""
+import os
+import sys
+from types import ModuleType
+from unittest.mock import patch
+
+import pytest
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from aether.core.tool_discovery import ToolDiscovery, _probe_i2c
+
+
+@pytest.fixture(scope="module")
+def manifest():
+    d = ToolDiscovery()
+    d.discover()
+    return d.manifest
+
+
+class TestToolDiscovery:
+    def test_platform_detected(self, manifest):
+        assert "platform" in manifest
+        assert manifest["platform"] != ""
+
+    def test_camera_found_or_missing(self, manifest):
+        hw = manifest.get("hardware", {})
+        cam = hw.get("camera", {})
+        # camera key must exist with an 'available' field
+        assert "available" in cam
+
+    def test_manifest_has_capability_score(self, manifest):
+        assert "capability_score" in manifest
+        score = manifest["capability_score"]
+        assert isinstance(score, (int, float))
+        assert 0 <= score <= 100
+
+    def test_available_tools_non_empty(self, manifest):
+        tools = manifest.get("available_tools", [])
+        assert isinstance(tools, list)
+        assert len(tools) > 0
+
+    def test_missing_capabilities_is_list(self, manifest):
+        missing = manifest.get("missing_capabilities", [])
+        assert isinstance(missing, list)
+        # On a dev machine at least some capabilities will be missing
+        # (e.g., GPIO on macOS), so the list should be non-empty
+        assert len(missing) > 0
+
+
+# ── I2C device enumeration (v3.7.3) ────────────────────────────────────
+
+
+def _fake_smbus2(ack_addrs=None, instantiation_error=None):
+    """Build a fake smbus2 module whose SMBus(1).read_byte ACKs (returns)
+    only at ack_addrs and raises OSError elsewhere. If instantiation_error
+    is set, SMBus(bus) raises it (simulates a missing /dev/i2c-N)."""
+    ack = set(ack_addrs or [])
+    mod = ModuleType("smbus2")
+
+    class _SMBus:
+        def __init__(self, bus):
+            if instantiation_error is not None:
+                raise instantiation_error
+            self.bus = bus
+
+        def read_byte(self, addr):
+            if addr in ack:
+                return 0
+            raise OSError("no device ACKed")
+
+        def close(self):
+            pass
+
+    mod.SMBus = _SMBus
+    return mod
+
+
+def test_probe_i2c_returns_devices_list_on_success():
+    fake = _fake_smbus2(ack_addrs=[0x14, 0x40])
+    with patch.dict(sys.modules, {"smbus2": fake}):
+        ok, info = _probe_i2c()
+    assert ok is True
+    assert info["available"] is True
+    assert info["bus"] == 1
+    assert info["type"] == "smbus2_i2c"
+    assert info["devices"] == [0x14, 0x40]  # ascending scan order
+
+
+def test_probe_i2c_returns_empty_list_on_no_devices():
+    fake = _fake_smbus2(ack_addrs=[])  # nothing ACKs
+    with patch.dict(sys.modules, {"smbus2": fake}):
+        ok, info = _probe_i2c()
+    assert ok is True           # bus opened fine, just no peripherals
+    assert info["devices"] == []
+
+
+def test_probe_i2c_returns_false_on_no_bus():
+    # SMBus(1) raises FileNotFoundError — /dev/i2c-1 absent / I2C disabled
+    fake = _fake_smbus2(instantiation_error=FileNotFoundError("/dev/i2c-1"))
+    with patch.dict(sys.modules, {"smbus2": fake}):
+        ok, info = _probe_i2c()
+    assert ok is False
+    assert info["available"] is False
+    assert info["devices"] == []
+
+
+def test_probe_i2c_never_crashes_boot():
+    # smbus2 import raises ImportError — must return False cleanly, no crash
+    with patch.dict(sys.modules, {"smbus2": None}):
+        ok, info = _probe_i2c()
+    assert ok is False
+    assert info["available"] is False
+    assert info["devices"] == []
+
+
+def test_capability_discovery_printer_shows_i2c_with_devices(capsys):
+    """With a device enumerated, the summary's i2c line must read OK with
+    the address — never the old '--- not detected'."""
+    with patch("aether.core.tool_discovery._probe_i2c",
+               return_value=(True, {"type": "smbus2_i2c", "available": True,
+                                    "bus": 1, "devices": [0x14]})):
+        d = ToolDiscovery()
+        d.discover()
+        d.print_summary()
+
+    out = capsys.readouterr().out
+    i2c_line = next(ln for ln in out.splitlines()
+                    if ln.strip().startswith(("[+] i2c", "[-] i2c")))
+    assert "[+]" in i2c_line
+    assert "OK" in i2c_line
+    assert "0x14" in i2c_line
+    assert "not detected" not in i2c_line

aether_robotics-3.7.2/VERSION

@@ -1 +0,0 @@
-3.7.2

aether_robotics-3.7.2/tests/test_tool_discovery.py

@@ -1,46 +0,0 @@
-"""Tests for ToolDiscovery: platform detection, manifest structure."""
-import os
-import sys
-
-import pytest
-
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
-
-from aether.core.tool_discovery import ToolDiscovery
-
-
-@pytest.fixture(scope="module")
-def manifest():
-    d = ToolDiscovery()
-    d.discover()
-    return d.manifest
-
-
-class TestToolDiscovery:
-    def test_platform_detected(self, manifest):
-        assert "platform" in manifest
-        assert manifest["platform"] != ""
-
-    def test_camera_found_or_missing(self, manifest):
-        hw = manifest.get("hardware", {})
-        cam = hw.get("camera", {})
-        # camera key must exist with an 'available' field
-        assert "available" in cam
-
-    def test_manifest_has_capability_score(self, manifest):
-        assert "capability_score" in manifest
-        score = manifest["capability_score"]
-        assert isinstance(score, (int, float))
-        assert 0 <= score <= 100
-
-    def test_available_tools_non_empty(self, manifest):
-        tools = manifest.get("available_tools", [])
-        assert isinstance(tools, list)
-        assert len(tools) > 0
-
-    def test_missing_capabilities_is_list(self, manifest):
-        missing = manifest.get("missing_capabilities", [])
-        assert isinstance(missing, list)
-        # On a dev machine at least some capabilities will be missing
-        # (e.g., GPIO on macOS), so the list should be non-empty
-        assert len(missing) > 0