aether-robotics 3.0.0__py3-none-any.whl

aether/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "3.0.0"
+__author__ = "Chahel Paatur"

aether/__main__.py

@@ -0,0 +1,10 @@
+import sys
+import os
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+def main():
+    import main as aether_main
+    aether_main.run()
+
+if __name__ == '__main__':
+    main()

aether/actions/abstract_actions.py

@@ -0,0 +1,136 @@
+"""
+Action Abstraction Layer: hardware-independent action definitions.
+Each AbstractAction defines what the action means, not how it's implemented.
+"""
+from abc import ABC, abstractmethod
+from typing import Dict, Optional
+from dataclasses import dataclass, field
+
+
+@dataclass
+class ActionResult:
+    action: str
+    success: bool
+    reason: str = ""
+    state: Dict = field(default_factory=dict)
+
+
+class AbstractAction(ABC):
+    name: str = ""
+
+    @abstractmethod
+    def preconditions(self, state: Dict) -> bool:
+        """Returns True if action can be executed given current state."""
+        ...
+
+    @abstractmethod
+    def expected_effect(self, state: Dict) -> Dict:
+        """Returns expected state changes after action."""
+        ...
+
+    def description(self) -> str:
+        return f"Abstract action: {self.name}"
+
+
+class MoveForward(AbstractAction):
+    name = "move_forward"
+
+    def preconditions(self, state: Dict) -> bool:
+        return not state.get("obstacles_nearby") or len(state["obstacles_nearby"]) == 0
+
+    def expected_effect(self, state: Dict) -> Dict:
+        return {"agent_moved": True, "direction": "forward"}
+
+    def description(self) -> str:
+        return "Move the agent forward in its current heading direction"
+
+
+class FollowTarget(AbstractAction):
+    name = "follow_target"
+
+    def preconditions(self, state: Dict) -> bool:
+        return (
+            state.get("target_detected", False)
+            and state.get("target_info") is not None
+            and "camera" not in state.get("failed_sensors", [])
+        )
+
+    def expected_effect(self, state: Dict) -> Dict:
+        return {"closer_to_target": True, "following": True}
+
+    def description(self) -> str:
+        return "Move toward the nearest detected target"
+
+
+class AvoidObstacle(AbstractAction):
+    name = "avoid_obstacle"
+
+    def preconditions(self, state: Dict) -> bool:
+        return len(state.get("obstacles_nearby", [])) > 0
+
+    def expected_effect(self, state: Dict) -> Dict:
+        return {"obstacle_avoided": True, "heading_changed": True}
+
+    def description(self) -> str:
+        return "Steer away from detected obstacles"
+
+
+class Stop(AbstractAction):
+    name = "stop"
+
+    def preconditions(self, state: Dict) -> bool:
+        return True  # can always stop
+
+    def expected_effect(self, state: Dict) -> Dict:
+        return {"velocity": 0, "stopped": True}
+
+    def description(self) -> str:
+        return "Halt all movement immediately"
+
+
+class ScanEnvironment(AbstractAction):
+    name = "scan_environment"
+
+    def preconditions(self, state: Dict) -> bool:
+        sensors = state.get("failed_sensors", [])
+        return "camera" not in sensors or "ultrasonic" not in sensors
+
+    def expected_effect(self, state: Dict) -> Dict:
+        return {"environment_mapped": True, "obstacles_known": True}
+
+    def description(self) -> str:
+        return "Use available sensors to observe and map surroundings"
+
+
+class Turn(AbstractAction):
+    name = "turn"
+
+    def preconditions(self, state: Dict) -> bool:
+        return "wheels" not in state.get("failed_actuators", [])
+
+    def expected_effect(self, state: Dict) -> Dict:
+        return {"heading_changed": True}
+
+    def description(self) -> str:
+        return "Rotate the agent in place"
+
+
+ACTION_REGISTRY: Dict[str, AbstractAction] = {
+    "move_forward": MoveForward(),
+    "follow_target": FollowTarget(),
+    "avoid_obstacle": AvoidObstacle(),
+    "stop": Stop(),
+    "scan_environment": ScanEnvironment(),
+    "turn": Turn(),
+}
+
+
+def get_action(name: str) -> Optional[AbstractAction]:
+    return ACTION_REGISTRY.get(name)
+
+
+def check_preconditions(action_name: str, state: Dict) -> bool:
+    action = get_action(action_name)
+    if action is None:
+        return False
+    return action.preconditions(state)

aether/adapters/base_adapter.py

@@ -0,0 +1,32 @@
+"""
+Base hardware adapter ABC: uniform interface all robot adapters must implement.
+"""
+from abc import ABC, abstractmethod
+from typing import Dict, Tuple
+
+
+class HardwareAdapter(ABC):
+    """Abstract base class for all robot hardware adapters."""
+
+    @abstractmethod
+    def execute(self, action: str, state: Dict) -> Tuple[Dict, bool]:
+        """Execute action. Returns (result_dict, success)."""
+        ...
+
+    @abstractmethod
+    def is_action_available(self, action: str) -> bool:
+        """Check if an action is currently executable."""
+        ...
+
+    @abstractmethod
+    def get_degradation_state(self) -> Dict:
+        """Return current degradation levels per subsystem (0=healthy, 1=failed)."""
+        ...
+
+    def get_actuator_state(self) -> Dict:
+        """Return current actuator states."""
+        return {}
+
+    def simulate_degradation(self, degradation_level: float) -> None:
+        """Inject simulated degradation for testing (0=none, 1=full failure)."""
+        pass

aether/adapters/drone_adapter.py

@@ -0,0 +1,67 @@
+"""
+DroneAdapter v3: stub adapter for drone hardware, same interface as RoverAdapter.
+Raises NotImplementedError for unimplemented flight-specific actions.
+"""
+from typing import Dict, Tuple
+from .base_adapter import HardwareAdapter
+
+
+class DroneAdapter(HardwareAdapter):
+    """Drone adapter stub — implements interface, flight controller integration pending."""
+
+    ROBOT_TYPE = "drone"
+    DEFAULT_ALTITUDE = 5.0
+
+    def __init__(self, environment, max_speed: float = 2.0):
+        self.env = environment
+        self.max_speed = max_speed
+        self.altitude = self.DEFAULT_ALTITUDE
+        self._thruster_degradation: float = 0.0
+
+    def execute(self, action: str, state: Dict) -> Tuple[Dict, bool]:
+        params = self._translate(action, state)
+        mapped = self._map_to_env_action(action)
+        obs, reward, done, info = self.env.step(mapped, params)
+        result = {
+            "observation": obs,
+            "reward": reward,
+            "done": done,
+            "info": info,
+            "action_taken": mapped,
+            "state_dict": self.env.get_state_dict(),
+        }
+        return result, not info.get("collision", False)
+
+    def is_action_available(self, action: str) -> bool:
+        if "thrusters" in self.env.failed_actuators and action not in ("stop", "emergency_stop"):
+            return False
+        return True
+
+    def get_degradation_state(self) -> Dict:
+        return {"thrusters": self._thruster_degradation}
+
+    def simulate_degradation(self, level: float) -> None:
+        self._thruster_degradation = min(1.0, level)
+
+    def _translate(self, action: str, state: Dict) -> Dict:
+        eff_speed = self.max_speed * (1.0 - self._thruster_degradation * 0.9)
+        if action == "move_forward":
+            return {"speed": eff_speed, "altitude": self.altitude}
+        elif action == "hover":
+            return {"speed": 0, "altitude": self.altitude}
+        elif action == "avoid_obstacle":
+            return {"altitude": self.altitude + 3.0, "speed": eff_speed * 0.5}
+        elif action in ("turn_left", "turn_right"):
+            return {"altitude": self.altitude}
+        return {"speed": 0, "altitude": self.altitude}
+
+    def _map_to_env_action(self, action: str) -> str:
+        mapping = {
+            "hover": "stop",
+            "emergency_stop": "stop",
+            "safe_mode": "stop",
+            "turn_left": "turn_left",
+            "turn_right": "turn_right",
+            "follow_target": "follow_target",
+        }
+        return mapping.get(action, action)

aether/adapters/rover_adapter.py

@@ -0,0 +1,87 @@
+"""
+RoverAdapter v3: translates abstract actions into rover hardware commands.
+Implements HardwareAdapter interface with degradation simulation.
+"""
+from typing import Dict, Optional, Tuple
+from .base_adapter import HardwareAdapter
+
+
+class RoverAdapter(HardwareAdapter):
+    """Full rover adapter with degradation simulation and actuator state tracking."""
+
+    ROBOT_TYPE = "rover"
+
+    def __init__(self, environment, max_speed: float = 1.0):
+        self.env = environment
+        self.max_speed = max_speed
+        self._wheel_degradation: float = 0.0
+        self._arm_degradation: float = 0.0
+        self._actuator_state: Dict = {"wheels": "nominal", "arm": "nominal"}
+
+    def execute(self, action: str, state: Dict) -> Tuple[Dict, bool]:
+        """Execute abstract action → rover hardware command → env step."""
+        params = self._translate(action, state)
+        effective_action = self._map_to_env_action(action)
+        obs, reward, done, info = self.env.step(effective_action, params)
+        success = info.get("success", False) or not info.get("collision", False)
+        result = {
+            "observation": obs,
+            "reward": reward,
+            "done": done,
+            "info": info,
+            "action_taken": effective_action,
+            "state_dict": self.env.get_state_dict(),
+        }
+        return result, success
+
+    def is_action_available(self, action: str) -> bool:
+        if "wheels" in self.env.failed_actuators and action in (
+                "move_forward", "move_backward", "turn_left", "turn_right", "follow_target"):
+            return False
+        return True
+
+    def get_degradation_state(self) -> Dict:
+        return {
+            "wheels": self._wheel_degradation,
+            "arm": self._arm_degradation,
+        }
+
+    def get_actuator_state(self) -> Dict:
+        return dict(self._actuator_state)
+
+    def simulate_degradation(self, degradation_level: float) -> None:
+        self._wheel_degradation = min(1.0, degradation_level)
+        if self._wheel_degradation > 0.8:
+            self._actuator_state["wheels"] = "critical"
+        elif self._wheel_degradation > 0.4:
+            self._actuator_state["wheels"] = "degraded"
+
+    def _translate(self, action: str, state: Dict) -> Dict:
+        eff_speed = self.max_speed * (1.0 - self._wheel_degradation * 0.8)
+        if action == "move_forward":
+            return {"speed": eff_speed}
+        elif action == "move_backward":
+            return {"speed": eff_speed * 0.5}
+        elif action in ("turn_left", "turn_right"):
+            return {}
+        elif action == "follow_target":
+            return {"speed": eff_speed, "target": state.get("target_info")}
+        elif action in ("stop", "emergency_stop"):
+            return {"speed": 0}
+        elif action == "scan":
+            return {}
+        elif action == "safe_mode":
+            return {"speed": 0}
+        return {}
+
+    def _map_to_env_action(self, action: str) -> str:
+        mapping = {
+            "turn_left": "turn_left",
+            "turn_right": "turn_right",
+            "follow_target": "follow_target",
+            "emergency_stop": "stop",
+            "safe_mode": "stop",
+            "scan": "scan_environment",
+            "report_state": "scan_environment",
+        }
+        return mapping.get(action, action)