foodforthought-cli 0.2.7__py3-none-any.whl → 0.2.8__py3-none-any.whl

ate/robot/manager.py

@@ -0,0 +1,270 @@
+"""
+Robot Manager - unified interface for managing robot connections.
+
+Handles:
+- Loading robots from profiles
+- Connecting/disconnecting
+- Managing multiple robots
+"""
+
+from typing import Dict, List, Optional, Any
+from dataclasses import dataclass
+
+from .profiles import RobotProfile, load_profile, list_profiles
+from .registry import KNOWN_ROBOTS, RobotType
+from .introspection import get_capabilities, get_methods
+
+
+@dataclass
+class ManagedRobot:
+    """A robot instance managed by RobotManager."""
+    profile: RobotProfile
+    robot_type: RobotType
+    instance: Any = None
+    connected: bool = False
+
+
+class RobotManager:
+    """
+    Manages robot connections and lifecycle.
+
+    Example:
+        manager = RobotManager()
+
+        # Load from profile
+        dog = manager.load("my_mechdog")
+        dog.connect()
+
+        # Use robot
+        dog.instance.stand()
+        dog.instance.walk(Vector3.forward())
+
+        # Disconnect
+        manager.disconnect_all()
+    """
+
+    def __init__(self):
+        self._robots: Dict[str, ManagedRobot] = {}
+
+    def load(self, profile_name: str) -> Optional[ManagedRobot]:
+        """
+        Load a robot from a saved profile.
+
+        Args:
+            profile_name: Name of the profile
+
+        Returns:
+            ManagedRobot or None if profile not found
+        """
+        profile = load_profile(profile_name)
+        if profile is None:
+            return None
+
+        robot_type = KNOWN_ROBOTS.get(profile.robot_type)
+        if robot_type is None:
+            print(f"Unknown robot type: {profile.robot_type}")
+            return None
+
+        managed = ManagedRobot(
+            profile=profile,
+            robot_type=robot_type,
+        )
+
+        self._robots[profile_name] = managed
+        return managed
+
+    def create(
+        self,
+        name: str,
+        robot_type: str,
+        **config
+    ) -> Optional[ManagedRobot]:
+        """
+        Create a robot instance without loading from profile.
+
+        Args:
+            name: Name for this robot
+            robot_type: Robot type ID
+            **config: Configuration options
+
+        Returns:
+            ManagedRobot
+        """
+        rtype = KNOWN_ROBOTS.get(robot_type)
+        if rtype is None:
+            print(f"Unknown robot type: {robot_type}")
+            return None
+
+        profile = RobotProfile(
+            name=name,
+            robot_type=robot_type,
+            **config
+        )
+
+        managed = ManagedRobot(
+            profile=profile,
+            robot_type=rtype,
+        )
+
+        self._robots[name] = managed
+        return managed
+
+    def connect(self, name: str) -> bool:
+        """
+        Connect to a loaded robot.
+
+        Args:
+            name: Robot name
+
+        Returns:
+            True if connected successfully
+        """
+        managed = self._robots.get(name)
+        if managed is None:
+            print(f"Robot not loaded: {name}")
+            return False
+
+        # Create robot instance
+        instance = self._create_instance(managed)
+        if instance is None:
+            return False
+
+        managed.instance = instance
+
+        # Connect
+        result = instance.connect()
+        if result.success:
+            managed.connected = True
+            return True
+        else:
+            print(f"Connection failed: {result.message}")
+            return False
+
+    def disconnect(self, name: str) -> bool:
+        """
+        Disconnect from a robot.
+
+        Args:
+            name: Robot name
+
+        Returns:
+            True if disconnected
+        """
+        managed = self._robots.get(name)
+        if managed is None or not managed.connected:
+            return True
+
+        if managed.instance:
+            managed.instance.disconnect()
+            managed.connected = False
+
+        return True
+
+    def disconnect_all(self) -> None:
+        """Disconnect from all robots."""
+        for name in list(self._robots.keys()):
+            self.disconnect(name)
+
+    def get(self, name: str) -> Optional[Any]:
+        """
+        Get a robot instance.
+
+        Args:
+            name: Robot name
+
+        Returns:
+            Robot instance or None
+        """
+        managed = self._robots.get(name)
+        if managed and managed.instance:
+            return managed.instance
+        return None
+
+    def list_loaded(self) -> List[str]:
+        """List all loaded robots."""
+        return list(self._robots.keys())
+
+    def list_connected(self) -> List[str]:
+        """List all connected robots."""
+        return [
+            name for name, managed in self._robots.items()
+            if managed.connected
+        ]
+
+    def get_info(self, name: str) -> Optional[Dict[str, Any]]:
+        """
+        Get information about a loaded robot.
+
+        Args:
+            name: Robot name
+
+        Returns:
+            Dict with robot info
+        """
+        managed = self._robots.get(name)
+        if managed is None:
+            return None
+
+        info = {
+            "name": managed.profile.name,
+            "type": managed.robot_type.name,
+            "manufacturer": managed.robot_type.manufacturer,
+            "archetype": managed.robot_type.archetype,
+            "connected": managed.connected,
+            "profile": {
+                "serial_port": managed.profile.serial_port,
+                "camera_ip": managed.profile.camera_ip,
+                "has_camera": managed.profile.has_camera,
+                "has_arm": managed.profile.has_arm,
+            },
+        }
+
+        if managed.instance:
+            info["capabilities"] = list(get_capabilities(managed.instance).keys())
+            info["methods"] = {
+                cap: [m.name for m in methods]
+                for cap, methods in get_methods(managed.instance).items()
+            }
+
+        return info
+
+    def _create_instance(self, managed: ManagedRobot) -> Optional[Any]:
+        """Create a robot instance from profile and type."""
+        rtype = managed.robot_type
+        profile = managed.profile
+
+        # Import the driver module dynamically
+        try:
+            import importlib
+            module = importlib.import_module(rtype.driver_module)
+            driver_class = getattr(module, rtype.driver_class)
+            config_class = getattr(module, rtype.config_class, None)
+        except (ImportError, AttributeError) as e:
+            print(f"Failed to import driver: {e}")
+            return None
+
+        # Build configuration
+        if config_class:
+            config_kwargs = {
+                "port": profile.serial_port or "/dev/ttyUSB0",
+            }
+
+            if profile.has_camera and profile.camera_ip:
+                config_kwargs["has_camera"] = True
+                config_kwargs["camera_ip"] = profile.camera_ip
+                config_kwargs["camera_port"] = profile.camera_port
+                config_kwargs["camera_stream_port"] = profile.camera_stream_port
+
+            if profile.has_arm:
+                config_kwargs["has_arm"] = True
+
+            config = config_class(**config_kwargs)
+            return driver_class(config=config)
+        else:
+            return driver_class()
+
+    def __enter__(self) -> "RobotManager":
+        return self
+
+    def __exit__(self, *args) -> None:
+        self.disconnect_all()

ate/robot/profiles.py

@@ -0,0 +1,275 @@
+"""
+Robot profiles - saved configurations for easy robot setup.
+
+Profiles are stored in ~/.ate/robots/ as JSON files.
+Users can create, edit, and share profiles.
+"""
+
+import os
+import json
+from dataclasses import dataclass, field, asdict
+from typing import Dict, List, Optional, Any
+from pathlib import Path
+
+
+# Default profile directory
+def get_profiles_dir() -> Path:
+    """Get the profiles directory, creating if needed."""
+    ate_dir = Path.home() / ".ate"
+    profiles_dir = ate_dir / "robots"
+    profiles_dir.mkdir(parents=True, exist_ok=True)
+    return profiles_dir
+
+
+@dataclass
+class RobotProfile:
+    """
+    A saved robot configuration.
+
+    Contains everything needed to connect to and use a robot.
+    """
+    # Identity
+    name: str                           # User-chosen name for this robot
+    robot_type: str                     # ID of robot type from registry
+
+    # Serial connection
+    serial_port: Optional[str] = None
+    baud_rate: int = 115200
+
+    # Network connection
+    ip_address: Optional[str] = None
+    camera_ip: Optional[str] = None
+    camera_port: int = 80
+    camera_stream_port: int = 81
+
+    # Robot-specific config
+    has_arm: bool = False
+    has_camera: bool = False
+    has_gripper: bool = False
+
+    # Custom settings
+    settings: Dict[str, Any] = field(default_factory=dict)
+
+    # Metadata
+    description: str = ""
+    created_at: Optional[str] = None
+    updated_at: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for YAML serialization."""
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "RobotProfile":
+        """Create from dictionary."""
+        return cls(**data)
+
+
+def load_profile(name: str) -> Optional[RobotProfile]:
+    """
+    Load a robot profile by name.
+
+    Args:
+        name: Profile name (without .json extension)
+
+    Returns:
+        RobotProfile or None if not found
+    """
+    profiles_dir = get_profiles_dir()
+    profile_path = profiles_dir / f"{name}.json"
+
+    if not profile_path.exists():
+        return None
+
+    try:
+        with open(profile_path, "r") as f:
+            data = json.load(f)
+            return RobotProfile.from_dict(data)
+    except Exception as e:
+        print(f"Error loading profile: {e}")
+        return None
+
+
+def save_profile(profile: RobotProfile) -> bool:
+    """
+    Save a robot profile.
+
+    Args:
+        profile: Profile to save
+
+    Returns:
+        True if saved successfully
+    """
+    from datetime import datetime
+
+    profiles_dir = get_profiles_dir()
+    profile_path = profiles_dir / f"{profile.name}.json"
+
+    # Update timestamps
+    now = datetime.now().isoformat()
+    if profile.created_at is None:
+        profile.created_at = now
+    profile.updated_at = now
+
+    try:
+        with open(profile_path, "w") as f:
+            json.dump(profile.to_dict(), f, indent=2)
+        return True
+    except Exception as e:
+        print(f"Error saving profile: {e}")
+        return False
+
+
+def list_profiles() -> List[RobotProfile]:
+    """
+    List all saved robot profiles.
+
+    Returns:
+        List of profiles
+    """
+    profiles_dir = get_profiles_dir()
+    profiles = []
+
+    for file in profiles_dir.glob("*.json"):
+        try:
+            with open(file, "r") as f:
+                data = json.load(f)
+                profiles.append(RobotProfile.from_dict(data))
+        except Exception:
+            pass
+
+    return profiles
+
+
+def delete_profile(name: str) -> bool:
+    """
+    Delete a robot profile.
+
+    Args:
+        name: Profile name
+
+    Returns:
+        True if deleted
+    """
+    profiles_dir = get_profiles_dir()
+    profile_path = profiles_dir / f"{name}.json"
+
+    if profile_path.exists():
+        profile_path.unlink()
+        return True
+    return False
+
+
+def profile_exists(name: str) -> bool:
+    """Check if a profile exists."""
+    profiles_dir = get_profiles_dir()
+    return (profiles_dir / f"{name}.json").exists()
+
+
+def get_default_profile() -> Optional[RobotProfile]:
+    """
+    Get the default profile (if set).
+
+    The default profile is stored as 'default.yaml' or
+    a profile named 'default'.
+    """
+    profiles_dir = get_profiles_dir()
+
+    # Check for default marker
+    default_marker = profiles_dir / ".default"
+    if default_marker.exists():
+        with open(default_marker, "r") as f:
+            default_name = f.read().strip()
+            return load_profile(default_name)
+
+    # Fall back to profile named 'default'
+    return load_profile("default")
+
+
+def set_default_profile(name: str) -> bool:
+    """
+    Set a profile as the default.
+
+    Args:
+        name: Profile name
+
+    Returns:
+        True if set successfully
+    """
+    if not profile_exists(name):
+        return False
+
+    profiles_dir = get_profiles_dir()
+    default_marker = profiles_dir / ".default"
+
+    with open(default_marker, "w") as f:
+        f.write(name)
+
+    return True
+
+
+def create_profile_from_discovery(
+    name: str,
+    serial_port: Optional[str] = None,
+    camera_ip: Optional[str] = None,
+    robot_type: str = "hiwonder_mechdog",
+) -> RobotProfile:
+    """
+    Create a profile from discovered devices.
+
+    Helper for the setup wizard.
+    """
+    profile = RobotProfile(
+        name=name,
+        robot_type=robot_type,
+        serial_port=serial_port,
+        camera_ip=camera_ip,
+        has_camera=camera_ip is not None,
+    )
+
+    return profile
+
+
+# Built-in profile templates
+PROFILE_TEMPLATES: Dict[str, RobotProfile] = {
+    "mechdog_basic": RobotProfile(
+        name="mechdog_basic",
+        robot_type="hiwonder_mechdog",
+        description="Basic MechDog setup without camera or arm",
+        serial_port="/dev/cu.usbserial-10",  # Common macOS port
+        has_camera=False,
+        has_arm=False,
+    ),
+    "mechdog_camera": RobotProfile(
+        name="mechdog_camera",
+        robot_type="hiwonder_mechdog",
+        description="MechDog with visual module (camera)",
+        serial_port="/dev/cu.usbserial-10",
+        has_camera=True,
+        camera_ip="192.168.1.100",
+    ),
+    "mechdog_full": RobotProfile(
+        name="mechdog_full",
+        robot_type="hiwonder_mechdog",
+        description="Full MechDog setup with arm and camera",
+        serial_port="/dev/cu.usbserial-10",
+        has_camera=True,
+        has_arm=True,
+        camera_ip="192.168.1.100",
+    ),
+    "simulation": RobotProfile(
+        name="simulation",
+        robot_type="simulation",
+        description="Simulated robot for testing without hardware",
+    ),
+}
+
+
+def get_template(template_name: str) -> Optional[RobotProfile]:
+    """Get a profile template."""
+    return PROFILE_TEMPLATES.get(template_name)
+
+
+def list_templates() -> List[str]:
+    """List available profile templates."""
+    return list(PROFILE_TEMPLATES.keys())