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

ate/robot/registry.py

@@ -0,0 +1,319 @@
+"""
+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.",
+
+    connection_types={ConnectionType.SERIAL, ConnectionType.WIFI},
+    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,
+    },
+
+    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

ate/robot/skill_upload.py

@@ -0,0 +1,393 @@
+"""
+Upload skill libraries and calibrations to FoodforThought.
+
+Creates artifacts with proper lineage:
+- Raw: pose images from dual cameras
+- Processed: servo calibration data
+- Labeled: named poses with semantic labels
+- Skill: generated Python skill code
+"""
+
+import os
+import json
+import base64
+import requests
+from datetime import datetime
+from typing import Optional, Dict, Any, List
+from pathlib import Path
+
+from .calibration import RobotCalibration, load_calibration
+from .visual_labeler import SkillLibrary, load_skill_library
+
+
+# API configuration
+BASE_URL = os.getenv("ATE_API_URL", "https://www.kindly.fyi/api")
+CONFIG_FILE = Path.home() / ".ate" / "config.json"
+
+
+class SkillLibraryUploader:
+    """
+    Uploads skill libraries to FoodforThought.
+
+    Creates a complete data lineage:
+    raw (images) → processed (calibration) → labeled (poses) → skill (code)
+    """
+
+    def __init__(
+        self,
+        base_url: str = BASE_URL,
+        api_key: Optional[str] = None,
+    ):
+        self.base_url = base_url
+        self.headers = {
+            "Content-Type": "application/json",
+        }
+
+        token = None
+
+        # Load from config file (device auth flow)
+        if CONFIG_FILE.exists():
+            try:
+                with open(CONFIG_FILE) as f:
+                    config = json.load(f)
+                    token = config.get("access_token") or config.get("api_key")
+            except Exception:
+                pass
+
+        # Override with explicit api_key or env var
+        if api_key:
+            token = api_key
+        elif os.getenv("ATE_API_KEY"):
+            token = os.getenv("ATE_API_KEY")
+
+        if token:
+            self.headers["Authorization"] = f"Bearer {token}"
+        else:
+            raise ValueError(
+                "Not logged in. Run 'ate login' to authenticate."
+            )
+
+    def _request(self, method: str, endpoint: str, **kwargs) -> Dict:
+        """Make HTTP request to API."""
+        url = f"{self.base_url}{endpoint}"
+        response = requests.request(method, url, headers=self.headers, **kwargs)
+        response.raise_for_status()
+        return response.json()
+
+    def get_or_create_project(self, name: str, description: str = "") -> str:
+        """Get existing project or create a new one."""
+        # Try to find existing project
+        try:
+            projects = self._request("GET", "/projects")
+            for project in projects.get("projects", []):
+                if project.get("name") == name:
+                    return project["id"]
+        except Exception:
+            pass
+
+        # Create new project
+        response = self._request("POST", "/projects", json={
+            "name": name,
+            "description": description or f"Robot skill library for {name}",
+            "visibility": "private",
+        })
+        return response.get("project", {}).get("id")
+
+    def upload_skill_library(
+        self,
+        library: SkillLibrary,
+        calibration: RobotCalibration,
+        project_id: Optional[str] = None,
+        include_images: bool = True,
+    ) -> Dict[str, Any]:
+        """
+        Upload a complete skill library to FoodforThought.
+
+        Creates artifacts with lineage:
+        1. Raw: pose images
+        2. Processed: servo calibration
+        3. Labeled: poses with semantic labels
+        4. Skill: generated Python code
+
+        Args:
+            library: SkillLibrary to upload
+            calibration: RobotCalibration with servo data
+            project_id: Optional project ID (will create if not provided)
+            include_images: Whether to upload pose images
+
+        Returns:
+            Dict with artifact IDs and URLs
+        """
+        result = {
+            "project_id": None,
+            "artifacts": [],
+            "lineage": [],
+        }
+
+        # Get or create project
+        if not project_id:
+            project_id = self.get_or_create_project(
+                f"{library.robot_name}_skills",
+                f"Skill library for {library.robot_model}",
+            )
+        result["project_id"] = project_id
+
+        # 1. Upload pose images as raw artifacts
+        image_artifact_ids = []
+        if include_images:
+            images_dir = Path.home() / ".ate" / "skill_images" / library.robot_name
+            if images_dir.exists():
+                for img_path in images_dir.glob("*.jpg"):
+                    try:
+                        artifact_id = self._upload_image_artifact(
+                            project_id=project_id,
+                            image_path=img_path,
+                            robot_name=library.robot_name,
+                        )
+                        image_artifact_ids.append(artifact_id)
+                        result["artifacts"].append({
+                            "id": artifact_id,
+                            "stage": "raw",
+                            "name": img_path.stem,
+                        })
+                    except Exception as e:
+                        print(f"Warning: Failed to upload {img_path.name}: {e}")
+
+        # 2. Upload calibration as processed artifact
+        calibration_artifact_id = self._upload_calibration_artifact(
+            project_id=project_id,
+            calibration=calibration,
+            parent_ids=image_artifact_ids[:5] if image_artifact_ids else None,  # Link to some images
+        )
+        result["artifacts"].append({
+            "id": calibration_artifact_id,
+            "stage": "processed",
+            "name": f"{library.robot_name}_calibration",
+        })
+
+        # 3. Upload poses as labeled artifacts
+        pose_artifact_ids = []
+        for pose_name, pose in calibration.poses.items():
+            pose_artifact_id = self._upload_pose_artifact(
+                project_id=project_id,
+                pose_name=pose_name,
+                pose=pose,
+                calibration=calibration,
+                parent_id=calibration_artifact_id,
+            )
+            pose_artifact_ids.append(pose_artifact_id)
+            result["artifacts"].append({
+                "id": pose_artifact_id,
+                "stage": "labeled",
+                "name": pose_name,
+            })
+
+        # 4. Upload skills as skill artifacts
+        for action_name, action in library.actions.items():
+            skill_artifact_id = self._upload_skill_artifact(
+                project_id=project_id,
+                action_name=action_name,
+                action=action,
+                library=library,
+                calibration=calibration,
+                trained_on=pose_artifact_ids,  # Skills trained on poses
+            )
+            result["artifacts"].append({
+                "id": skill_artifact_id,
+                "stage": "skill",
+                "name": action_name,
+            })
+
+        return result
+
+    def _upload_image_artifact(
+        self,
+        project_id: str,
+        image_path: Path,
+        robot_name: str,
+    ) -> str:
+        """Upload an image as a raw artifact."""
+        # Read and encode image
+        with open(image_path, "rb") as f:
+            image_data = base64.b64encode(f.read()).decode("utf-8")
+
+        response = self._request("POST", "/artifacts", json={
+            "projectId": project_id,
+            "name": image_path.stem,
+            "stage": "raw",
+            "type": "dataset",
+            "metadata": {
+                "robot_name": robot_name,
+                "image_type": "pose_capture",
+                "filename": image_path.name,
+                "format": "jpeg",
+                "source": "visual_labeler",
+                "captured_at": datetime.now().isoformat(),
+            },
+        })
+        return response.get("artifact", {}).get("id")
+
+    def _upload_calibration_artifact(
+        self,
+        project_id: str,
+        calibration: RobotCalibration,
+        parent_ids: Optional[List[str]] = None,
+    ) -> str:
+        """Upload servo calibration as a processed artifact."""
+        # Serialize calibration
+        calibration_data = {
+            "robot_model": calibration.robot_model,
+            "robot_name": calibration.robot_name,
+            "serial_port": calibration.serial_port,
+            "baud_rate": calibration.baud_rate,
+            "camera_url": calibration.camera_url,
+            "servos": {
+                str(sid): {
+                    "servo_id": s.servo_id,
+                    "name": s.name,
+                    "joint_type": s.joint_type.value,
+                    "min_value": s.min_value,
+                    "max_value": s.max_value,
+                    "center_value": s.center_value,
+                    "positions": s.positions,
+                }
+                for sid, s in calibration.servos.items()
+            },
+            "calibrated_at": calibration.calibrated_at,
+        }
+
+        response = self._request("POST", "/artifacts", json={
+            "projectId": project_id,
+            "name": f"{calibration.robot_name}_calibration",
+            "stage": "processed",
+            "type": "dataset",
+            "metadata": {
+                "robot_model": calibration.robot_model,
+                "robot_name": calibration.robot_name,
+                "servo_count": len(calibration.servos),
+                "pose_count": len(calibration.poses),
+                "calibration_data": calibration_data,
+                "source": "visual_labeler",
+            },
+        })
+        return response.get("artifact", {}).get("id")
+
+    def _upload_pose_artifact(
+        self,
+        project_id: str,
+        pose_name: str,
+        pose,
+        calibration: RobotCalibration,
+        parent_id: str,
+    ) -> str:
+        """Upload a named pose as a labeled artifact."""
+        # Build pose data with semantic labels
+        servo_labels = {}
+        for sid, value in pose.servo_positions.items():
+            servo_cal = calibration.servos.get(sid)
+            if servo_cal:
+                servo_labels[str(sid)] = {
+                    "name": servo_cal.name,
+                    "joint_type": servo_cal.joint_type.value,
+                    "value": value,
+                    "normalized": (value - servo_cal.min_value) / max(1, servo_cal.max_value - servo_cal.min_value),
+                }
+
+        response = self._request("POST", "/artifacts", json={
+            "projectId": project_id,
+            "name": pose_name,
+            "stage": "labeled",
+            "type": "dataset",
+            "parentArtifactId": parent_id,
+            "transformationType": "labeling",
+            "transformationNotes": f"Pose '{pose_name}' labeled from calibration",
+            "metadata": {
+                "robot_name": calibration.robot_name,
+                "pose_name": pose_name,
+                "description": pose.description,
+                "servo_positions": pose.servo_positions,
+                "servo_labels": servo_labels,
+                "transition_time_ms": pose.transition_time_ms,
+                "image_path": pose.image_path,
+                "source": "visual_labeler",
+            },
+        })
+        return response.get("artifact", {}).get("id")
+
+    def _upload_skill_artifact(
+        self,
+        project_id: str,
+        action_name: str,
+        action,
+        library: SkillLibrary,
+        calibration: RobotCalibration,
+        trained_on: List[str],
+    ) -> str:
+        """Upload a generated skill as a skill artifact."""
+        # Generate skill code
+        from .visual_labeler import DualCameraLabeler
+        labeler = DualCameraLabeler(
+            serial_port=calibration.serial_port or "",
+            robot_name=library.robot_name,
+            robot_model=library.robot_model,
+        )
+        labeler.calibrator.calibration = calibration
+        skill_code = labeler.generate_skill_code(action)
+
+        response = self._request("POST", "/artifacts", json={
+            "projectId": project_id,
+            "name": action_name,
+            "stage": "skill",
+            "type": "code",
+            "trainedOn": trained_on,
+            "trainingNotes": f"Skill '{action_name}' generated from {len(action.steps)} poses",
+            "metadata": {
+                "robot_model": library.robot_model,
+                "robot_name": library.robot_name,
+                "action_type": action.action_type.value,
+                "description": action.description,
+                "steps": [s.to_dict() for s in action.steps],
+                "skill_code": skill_code,
+                "tags": action.tags,
+                "source": "visual_labeler",
+                "generated_at": datetime.now().isoformat(),
+            },
+        })
+        return response.get("artifact", {}).get("id")
+
+
+def upload_skill_library(
+    robot_name: str,
+    project_id: Optional[str] = None,
+    include_images: bool = True,
+    api_key: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Convenience function to upload a skill library.
+
+    Args:
+        robot_name: Name of the robot (matches calibration/library filenames)
+        project_id: Optional project ID
+        include_images: Whether to upload pose images
+        api_key: Optional API key
+
+    Returns:
+        Dict with upload results
+    """
+    # Load calibration
+    calibration = load_calibration(robot_name)
+    if not calibration:
+        raise ValueError(f"No calibration found for: {robot_name}")
+
+    # Load skill library
+    library = load_skill_library(robot_name)
+    if not library:
+        raise ValueError(f"No skill library found for: {robot_name}")
+
+    uploader = SkillLibraryUploader(api_key=api_key)
+    return uploader.upload_skill_library(
+        library=library,
+        calibration=calibration,
+        project_id=project_id,
+        include_images=include_images,
+    )