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

ate/robot/profiles.py

@@ -0,0 +1,281 @@
+"""
+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
+
+    # BLE connection
+    use_ble: bool = False                 # Use BLE instead of serial
+    ble_address: Optional[str] = None     # BLE device address
+    ble_service_uuid: str = "0000ffe0-0000-1000-8000-00805f9b34fb"  # ESP32/HM-10 default
+    ble_char_uuid: str = "0000ffe1-0000-1000-8000-00805f9b34fb"     # RX/TX characteristic
+
+    # 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())

ate/robot/registry.py

@@ -0,0 +1,322 @@
+"""
+Registry of known robot types and their configurations.
+
+This is how we know what robots are supported and how to configure them.
+Community contributions can add new robots here.
+"""
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Set, Optional, Type, Any
+from enum import Enum, auto
+
+
+class ConnectionType(Enum):
+    """How to connect to the robot."""
+    SERIAL = auto()      # USB serial (pyserial)
+    WIFI = auto()        # WiFi/HTTP
+    ROS2 = auto()        # ROS2 topics/services
+    BLUETOOTH = auto()   # Bluetooth serial
+    ETHERNET = auto()    # Direct ethernet
+    SIMULATION = auto()  # No hardware, simulated
+
+
+@dataclass
+class RobotType:
+    """Definition of a known robot type."""
+    id: str                              # Unique identifier
+    name: str                            # Display name
+    manufacturer: str                    # Who makes it
+    archetype: str                       # quadruped, humanoid, arm, etc.
+    description: str                     # Human description
+
+    # Connection
+    connection_types: Set[ConnectionType] = field(default_factory=set)
+    default_connection: Optional[ConnectionType] = None
+
+    # Serial settings
+    serial_patterns: List[str] = field(default_factory=list)  # USB patterns to match
+    baud_rate: int = 115200
+
+    # Network settings
+    default_ports: Dict[str, int] = field(default_factory=dict)  # camera_port, stream_port, etc.
+    mdns_service: Optional[str] = None  # mDNS service type to discover
+
+    # Capabilities
+    capabilities: Set[str] = field(default_factory=set)
+    optional_capabilities: Set[str] = field(default_factory=set)
+
+    # Driver info
+    driver_module: str = ""              # Python module path
+    driver_class: str = ""               # Class name
+    config_class: str = ""               # Config class name
+
+    # Documentation
+    setup_url: Optional[str] = None
+    image_url: Optional[str] = None
+
+
+# Registry of known robot types
+KNOWN_ROBOTS: Dict[str, RobotType] = {}
+
+
+def register_robot(robot: RobotType) -> None:
+    """Register a robot type."""
+    KNOWN_ROBOTS[robot.id] = robot
+
+
+def get_robot_info(robot_id: str) -> Optional[RobotType]:
+    """Get information about a robot type."""
+    return KNOWN_ROBOTS.get(robot_id)
+
+
+def list_robot_types() -> List[RobotType]:
+    """List all known robot types."""
+    return list(KNOWN_ROBOTS.values())
+
+
+def find_by_archetype(archetype: str) -> List[RobotType]:
+    """Find robots by archetype (quadruped, humanoid, etc.)."""
+    return [r for r in KNOWN_ROBOTS.values() if r.archetype == archetype]
+
+
+# =============================================================================
+# Built-in robot definitions
+# =============================================================================
+
+# HiWonder MechDog
+register_robot(RobotType(
+    id="hiwonder_mechdog",
+    name="MechDog",
+    manufacturer="HiWonder",
+    archetype="quadruped",
+    description="12 DOF quadruped robot with optional arm and camera. ESP32-based with MicroPython. Supports USB, WiFi, and Bluetooth LE.",
+
+    connection_types={ConnectionType.SERIAL, ConnectionType.WIFI, ConnectionType.BLUETOOTH},
+    default_connection=ConnectionType.SERIAL,
+
+    serial_patterns=[
+        "/dev/cu.usbserial-*",      # macOS
+        "/dev/ttyUSB*",             # Linux
+        "COM*",                      # Windows
+    ],
+    baud_rate=115200,
+
+    default_ports={
+        "camera_port": 80,
+        "camera_stream_port": 81,
+        # BLE configuration - ESP32 default BLE serial service
+        "ble_service_uuid": "0000ffe0-0000-1000-8000-00805f9b34fb",  # HM-10 compatible
+        "ble_char_uuid": "0000ffe1-0000-1000-8000-00805f9b34fb",     # RX/TX characteristic
+    },
+
+    capabilities={
+        "quadruped_locomotion",
+        "body_pose",
+        "imu",
+    },
+    optional_capabilities={
+        "camera",
+        "arm",
+        "gripper",
+    },
+
+    driver_module="ate.drivers.mechdog",
+    driver_class="MechDogDriver",
+    config_class="MechDogConfig",
+
+    setup_url="https://docs.kindly.fyi/robots/mechdog",
+))
+
+
+# Unitree Go1
+register_robot(RobotType(
+    id="unitree_go1",
+    name="Go1",
+    manufacturer="Unitree",
+    archetype="quadruped",
+    description="High-performance quadruped robot with cameras and optional arm.",
+
+    connection_types={ConnectionType.WIFI, ConnectionType.ETHERNET},
+    default_connection=ConnectionType.WIFI,
+
+    default_ports={
+        "control_port": 8082,
+        "camera_port": 8080,
+    },
+
+    capabilities={
+        "quadruped_locomotion",
+        "body_pose",
+        "imu",
+        "camera",
+        "depth_camera",
+    },
+    optional_capabilities={
+        "arm",
+        "gripper",
+        "lidar",
+    },
+
+    driver_module="ate.drivers.go1",
+    driver_class="Go1Driver",
+    config_class="Go1Config",
+))
+
+
+# Unitree Go2
+register_robot(RobotType(
+    id="unitree_go2",
+    name="Go2",
+    manufacturer="Unitree",
+    archetype="quadruped",
+    description="Advanced quadruped with AI capabilities, LiDAR, and ROS2 support.",
+
+    connection_types={ConnectionType.ROS2, ConnectionType.WIFI},
+    default_connection=ConnectionType.ROS2,
+
+    capabilities={
+        "quadruped_locomotion",
+        "body_pose",
+        "imu",
+        "camera",
+        "depth_camera",
+        "lidar",
+    },
+    optional_capabilities={
+        "arm",
+        "gripper",
+    },
+
+    driver_module="ate.drivers.go2",
+    driver_class="Go2Driver",
+    config_class="Go2Config",
+))
+
+
+# Boston Dynamics Spot
+register_robot(RobotType(
+    id="boston_dynamics_spot",
+    name="Spot",
+    manufacturer="Boston Dynamics",
+    archetype="quadruped",
+    description="Industrial quadruped robot with arm, cameras, and high autonomy.",
+
+    connection_types={ConnectionType.WIFI, ConnectionType.ETHERNET},
+    default_connection=ConnectionType.WIFI,
+
+    capabilities={
+        "quadruped_locomotion",
+        "body_pose",
+        "imu",
+        "camera",
+        "depth_camera",
+    },
+    optional_capabilities={
+        "arm",
+        "gripper",
+        "lidar",
+    },
+
+    driver_module="ate.drivers.spot",
+    driver_class="SpotDriver",
+    config_class="SpotConfig",
+))
+
+
+# Generic ROS2 robot
+register_robot(RobotType(
+    id="ros2_generic",
+    name="Generic ROS2 Robot",
+    manufacturer="Various",
+    archetype="custom",
+    description="Any robot accessible via ROS2 topics and services.",
+
+    connection_types={ConnectionType.ROS2},
+    default_connection=ConnectionType.ROS2,
+
+    capabilities=set(),  # Discovered from ROS2 topics
+    optional_capabilities={
+        "quadruped_locomotion",
+        "bipedal_locomotion",
+        "wheeled_locomotion",
+        "arm",
+        "gripper",
+        "camera",
+        "depth_camera",
+        "lidar",
+        "imu",
+    },
+
+    driver_module="ate.drivers.ros2_bridge",
+    driver_class="ROS2Bridge",
+    config_class="ROS2Config",
+))
+
+
+# Simulation robot
+register_robot(RobotType(
+    id="simulation",
+    name="Simulated Robot",
+    manufacturer="FoodforThought",
+    archetype="custom",
+    description="Software simulation for testing without hardware.",
+
+    connection_types={ConnectionType.SIMULATION},
+    default_connection=ConnectionType.SIMULATION,
+
+    capabilities={
+        "quadruped_locomotion",
+        "body_pose",
+        "camera",
+    },
+    optional_capabilities={
+        "arm",
+        "gripper",
+        "lidar",
+    },
+
+    driver_module="ate.drivers.simulation",
+    driver_class="SimulationDriver",
+    config_class="SimulationConfig",
+))
+
+
+class RobotRegistry:
+    """
+    Registry interface for robot types.
+
+    Provides methods to find and filter known robots.
+    """
+
+    @staticmethod
+    def list_all() -> List[RobotType]:
+        """List all known robot types."""
+        return list(KNOWN_ROBOTS.values())
+
+    @staticmethod
+    def get(robot_id: str) -> Optional[RobotType]:
+        """Get robot type by ID."""
+        return KNOWN_ROBOTS.get(robot_id)
+
+    @staticmethod
+    def find_by_archetype(archetype: str) -> List[RobotType]:
+        """Find robots by archetype."""
+        return [r for r in KNOWN_ROBOTS.values() if r.archetype == archetype]
+
+    @staticmethod
+    def find_by_capability(capability: str) -> List[RobotType]:
+        """Find robots that have a specific capability."""
+        return [
+            r for r in KNOWN_ROBOTS.values()
+            if capability in r.capabilities or capability in r.optional_capabilities
+        ]
+
+    @staticmethod
+    def find_by_connection(conn_type: ConnectionType) -> List[RobotType]:
+        """Find robots that support a connection type."""
+        return [r for r in KNOWN_ROBOTS.values() if conn_type in r.connection_types]
+
+    @staticmethod
+    def register(robot: RobotType) -> None:
+        """Register a new robot type."""
+        KNOWN_ROBOTS[robot.id] = robot