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

ate/robot/skill_upload.py

@@ -25,6 +25,116 @@ BASE_URL = os.getenv("ATE_API_URL", "https://www.kindly.fyi/api")
 CONFIG_FILE = Path.home() / ".ate" / "config.json"
 
 
+class APIError(Exception):
+    """
+    Custom exception for API errors with helpful context.
+
+    Provides:
+    - Status code and reason
+    - Parsed error message from API response
+    - Suggestions for fixing common issues
+    """
+
+    def __init__(
+        self,
+        message: str,
+        status_code: int = 0,
+        response_body: Optional[Dict] = None,
+        suggestions: Optional[List[str]] = None,
+    ):
+        self.status_code = status_code
+        self.response_body = response_body or {}
+        self.suggestions = suggestions or []
+
+        # Build helpful error message
+        parts = [message]
+
+        if self.response_body:
+            # Try to extract error details from response
+            error_detail = (
+                self.response_body.get("error") or
+                self.response_body.get("message") or
+                self.response_body.get("detail") or
+                self.response_body.get("errors")
+            )
+            if error_detail:
+                if isinstance(error_detail, list):
+                    error_detail = "; ".join(str(e) for e in error_detail)
+                parts.append(f"Details: {error_detail}")
+
+        if self.suggestions:
+            parts.append("Suggestions:")
+            for s in self.suggestions:
+                parts.append(f"  - {s}")
+
+        super().__init__("\n".join(parts))
+
+
+def parse_api_error(response: requests.Response, endpoint: str) -> APIError:
+    """
+    Parse API error response and return helpful APIError.
+
+    Analyzes common error patterns and provides actionable suggestions.
+    """
+    status = response.status_code
+    suggestions = []
+
+    # Try to parse response body
+    try:
+        body = response.json()
+    except Exception:
+        body = {"raw": response.text[:500] if response.text else "No response body"}
+
+    # Common error patterns and suggestions
+    if status == 400:
+        error_text = str(body).lower()
+
+        if "project" in endpoint:
+            suggestions.append("Use --project-id to specify an existing project")
+            suggestions.append("Check project name doesn't contain special characters")
+        elif "calibration" in endpoint:
+            suggestions.append("Ensure calibration file contains required fields: name, version, method")
+            suggestions.append("Check robot slug exists: ate robot identify --search <robot-name>")
+
+    elif status == 401:
+        suggestions.append("Session may have expired. Run: ate login")
+        suggestions.append("Check ATE_API_KEY environment variable if using API key auth")
+
+    elif status == 403:
+        suggestions.append("You may not have permission for this operation")
+        suggestions.append("Check if the project/resource is owned by another user")
+
+    elif status == 404:
+        error_text = str(body).lower()
+
+        if "robot" in error_text and "not found" in error_text:
+            suggestions.append("Robot slug may not exist in the database")
+            suggestions.append("Search for robots: ate robot identify --search <partial-name>")
+            suggestions.append("List available robots: ate robot list")
+
+        elif "project" in endpoint:
+            suggestions.append("Project ID may be invalid or deleted")
+            suggestions.append("List your projects to find valid IDs")
+
+    elif status == 422:
+        suggestions.append("Request data validation failed")
+        if body.get("errors"):
+            for field, errors in body.get("errors", {}).items():
+                suggestions.append(f"Field '{field}': {errors}")
+
+    elif status >= 500:
+        suggestions.append("Server error - this is likely temporary")
+        suggestions.append("Try again in a few minutes")
+        suggestions.append("Report persistent issues at: https://github.com/kindlyrobotics/monorepo/issues")
+
+    return APIError(
+        message=f"API request failed: {status} {response.reason} for {endpoint}",
+        status_code=status,
+        response_body=body,
+        suggestions=suggestions,
+    )
+
+
 class SkillLibraryUploader:
     """
     Uploads skill libraries to FoodforThought.
@@ -68,11 +178,21 @@ class SkillLibraryUploader:
             )
 
     def _request(self, method: str, endpoint: str, **kwargs) -> Dict:
-        """Make HTTP request to API."""
+        """
+        Make HTTP request to API with improved error handling.
+
+        Raises APIError with helpful suggestions on failure.
+        """
         url = f"{self.base_url}{endpoint}"
         response = requests.request(method, url, headers=self.headers, **kwargs)
-        response.raise_for_status()
-        return response.json()
+
+        if not response.ok:
+            raise parse_api_error(response, endpoint)
+
+        try:
+            return response.json()
+        except json.JSONDecodeError:
+            return {"raw": response.text}
 
     def get_or_create_project(self, name: str, description: str = "") -> str:
         """Get existing project or create a new one."""
@@ -334,6 +454,48 @@ class SkillLibraryUploader:
         labeler.calibrator.calibration = calibration
         skill_code = labeler.generate_skill_code(action)
 
+        # Determine skill type based on action structure
+        skill_type = "primitive"  # Default
+        dependencies = []
+        hardware_requirements = []
+
+        # Infer hardware requirements from servo usage
+        servo_ids = set()
+        for step in action.steps:
+            if hasattr(step, 'pose_name') and step.pose_name:
+                pose = calibration.poses.get(step.pose_name)
+                if pose:
+                    servo_ids.update(pose.servo_positions.keys())
+
+        # Map servo IDs to hardware requirements
+        for sid in servo_ids:
+            servo = calibration.servos.get(sid)
+            if servo:
+                if "gripper" in servo.name.lower():
+                    if "gripper" not in hardware_requirements:
+                        hardware_requirements.append("gripper")
+                elif "arm" in servo.name.lower() or "shoulder" in servo.name.lower() or "elbow" in servo.name.lower():
+                    if "arm" not in hardware_requirements:
+                        hardware_requirements.append("arm")
+                elif "leg" in servo.name.lower() or "hip" in servo.name.lower() or "thigh" in servo.name.lower():
+                    if "legs" not in hardware_requirements:
+                        hardware_requirements.append("legs")
+
+        # Determine skill type based on complexity
+        if len(action.steps) == 1:
+            skill_type = "primitive"
+        elif len(action.steps) <= 5:
+            skill_type = "compound"
+        else:
+            skill_type = "sequence"
+
+        # If action has perception tags, it's a behavior
+        if action.tags:
+            if any(t in ["perception", "detection", "visual", "feedback"] for t in action.tags):
+                skill_type = "behavior"
+                if "camera" not in hardware_requirements:
+                    hardware_requirements.append("camera")
+
         response = self._request("POST", "/artifacts", json={
             "projectId": project_id,
             "name": action_name,
@@ -351,11 +513,131 @@ class SkillLibraryUploader:
                 "tags": action.tags,
                 "source": "visual_labeler",
                 "generated_at": datetime.now().isoformat(),
+                # New skill hierarchy fields
+                "skill_type": skill_type,  # "primitive", "compound", "behavior"
+                "dependencies": dependencies,  # List of skill names this depends on
+                "hardware_requirements": hardware_requirements,  # ["arm", "gripper", "legs", "camera"]
+                "servo_count": len(servo_ids),
             },
         })
         return response.get("artifact", {}).get("id")
 
 
+def upload_primitives(
+    robot_name: str,
+    project_id: Optional[str] = None,
+    api_key: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Upload programmatic primitives from PrimitiveLibrary.
+
+    These are the cleanly-generated skills from primitives.py with proper
+    skill_type, dependencies, and hardware_requirements.
+
+    Args:
+        robot_name: Name of the robot
+        project_id: Optional project ID
+        api_key: Optional API key
+
+    Returns:
+        Dict with upload results
+    """
+    from .primitives import PrimitiveLibrary
+
+    uploader = SkillLibraryUploader(api_key=api_key)
+
+    # Get or create project
+    if not project_id:
+        project_id = uploader.get_or_create_project(
+            f"{robot_name}_primitives",
+            f"Primitive skill library for {robot_name}",
+        )
+
+    result = {
+        "project_id": project_id,
+        "artifacts": [],
+    }
+
+    # Create primitive library (without robot for now)
+    lib = PrimitiveLibrary(robot_interface=None)
+
+    # Upload primitives
+    for name, prim in lib.primitives.items():
+        response = uploader._request("POST", "/artifacts", json={
+            "projectId": project_id,
+            "name": name,
+            "stage": "skill",
+            "type": "code",
+            "metadata": {
+                "robot_name": robot_name,
+                "skill_type": "primitive",
+                "description": prim.description,
+                "servo_targets": {str(k): v for k, v in prim.servo_targets.items()},
+                "duration_ms": prim.duration_ms,
+                "hardware_requirements": [r.value for r in prim.hardware],
+                "dependencies": [],
+                "source": "primitives_library",
+            },
+        })
+        result["artifacts"].append({
+            "id": response.get("artifact", {}).get("id"),
+            "stage": "skill",
+            "name": name,
+            "skill_type": "primitive",
+        })
+
+    # Upload compound skills
+    for name, compound in lib.compounds.items():
+        response = uploader._request("POST", "/artifacts", json={
+            "projectId": project_id,
+            "name": name,
+            "stage": "skill",
+            "type": "code",
+            "metadata": {
+                "robot_name": robot_name,
+                "skill_type": "compound",
+                "description": compound.description,
+                "steps": compound.steps,
+                "hardware_requirements": [r.value for r in compound.hardware],
+                "dependencies": compound.steps,  # Each step is a dependency
+                "source": "primitives_library",
+            },
+        })
+        result["artifacts"].append({
+            "id": response.get("artifact", {}).get("id"),
+            "stage": "skill",
+            "name": name,
+            "skill_type": "compound",
+        })
+
+    # Upload behaviors
+    for name, behavior in lib.behaviors.items():
+        response = uploader._request("POST", "/artifacts", json={
+            "projectId": project_id,
+            "name": name,
+            "stage": "skill",
+            "type": "code",
+            "metadata": {
+                "robot_name": robot_name,
+                "skill_type": "behavior",
+                "description": behavior.description,
+                "steps": behavior.steps,
+                "hardware_requirements": [r.value for r in behavior.hardware],
+                "dependencies": [],  # Behaviors infer deps from steps
+                "requires_perception": True,
+                "source": "primitives_library",
+            },
+        })
+        result["artifacts"].append({
+            "id": response.get("artifact", {}).get("id"),
+            "stage": "skill",
+            "name": name,
+            "skill_type": "behavior",
+        })
+
+    return result
+
+
 def upload_skill_library(
     robot_name: str,
     project_id: Optional[str] = None,