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

ate/recording/session.py

@@ -0,0 +1,405 @@
+"""
+Recording session for capturing robot demonstrations.
+"""
+
+import time
+import json
+import uuid
+from datetime import datetime
+from dataclasses import dataclass, field, asdict
+from typing import Any, List, Optional, Dict, Callable
+from functools import wraps
+
+from ate.interfaces import RobotInterface, ActionResult
+
+
+@dataclass
+class RecordedCall:
+    """A single recorded interface method call."""
+
+    timestamp: float  # Unix timestamp (seconds)
+    relative_time: float  # Time since recording started (seconds)
+    interface: str  # Interface name (e.g., "QuadrupedLocomotion")
+    method: str  # Method name (e.g., "walk")
+    args: tuple  # Positional arguments (serialized)
+    kwargs: dict  # Keyword arguments (serialized)
+    result: Any  # Return value (serialized)
+    success: bool  # Whether the call succeeded
+    error: Optional[str] = None  # Error message if failed
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for serialization."""
+        return {
+            "timestamp": self.timestamp,
+            "relative_time": self.relative_time,
+            "interface": self.interface,
+            "method": self.method,
+            "args": self._serialize_args(self.args),
+            "kwargs": self._serialize_kwargs(self.kwargs),
+            "result": self._serialize_result(self.result),
+            "success": self.success,
+            "error": self.error,
+        }
+
+    def _serialize_args(self, args: tuple) -> list:
+        """Serialize arguments to JSON-compatible format."""
+        return [self._serialize_value(arg) for arg in args]
+
+    def _serialize_kwargs(self, kwargs: dict) -> dict:
+        """Serialize keyword arguments to JSON-compatible format."""
+        return {k: self._serialize_value(v) for k, v in kwargs.items()}
+
+    def _serialize_value(self, value: Any) -> Any:
+        """Serialize a single value."""
+        # Handle common types
+        if value is None or isinstance(value, (bool, int, float, str)):
+            return value
+        if isinstance(value, (list, tuple)):
+            return [self._serialize_value(v) for v in value]
+        if isinstance(value, dict):
+            return {k: self._serialize_value(v) for k, v in value.items()}
+
+        # Handle our interface types
+        if hasattr(value, '__dataclass_fields__'):
+            return {"__type__": type(value).__name__, **asdict(value)}
+        if hasattr(value, 'to_dict'):
+            return {"__type__": type(value).__name__, **value.to_dict()}
+
+        # Handle ActionResult
+        if isinstance(value, ActionResult):
+            return {
+                "__type__": "ActionResult",
+                "success": value.success,
+                "message": value.message,
+                "error": value.error,
+            }
+
+        # Fallback: convert to string
+        return {"__type__": type(value).__name__, "__str__": str(value)}
+
+    def _serialize_result(self, result: Any) -> Any:
+        """Serialize return value."""
+        return self._serialize_value(result)
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "RecordedCall":
+        """Create from dictionary."""
+        return cls(
+            timestamp=data["timestamp"],
+            relative_time=data["relative_time"],
+            interface=data["interface"],
+            method=data["method"],
+            args=tuple(data["args"]),
+            kwargs=data["kwargs"],
+            result=data["result"],
+            success=data["success"],
+            error=data.get("error"),
+        )
+
+
+@dataclass
+class RecordingMetadata:
+    """Metadata for a recording session."""
+
+    id: str  # Unique recording ID
+    name: str  # Human-readable name
+    robot_name: str  # Robot name from driver
+    robot_model: str  # Robot model from driver
+    robot_archetype: str  # Robot archetype (quadruped, etc.)
+    capabilities: List[str]  # Robot capabilities
+    start_time: float  # Unix timestamp
+    end_time: Optional[float] = None  # Unix timestamp
+    duration: Optional[float] = None  # Seconds
+    description: Optional[str] = None
+    tags: List[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "RecordingMetadata":
+        return cls(**data)
+
+
+class RecordingSession:
+    """
+    Context manager for recording robot demonstrations.
+
+    Wraps a robot driver to intercept and record all interface method calls.
+
+    Usage:
+        with RecordingSession(driver, name="my_demo") as session:
+            driver.stand()
+            driver.walk(Vector3.forward(), speed=0.3)
+
+        session.save("my_demo.demonstration")
+    """
+
+    def __init__(
+        self,
+        driver: RobotInterface,
+        name: str = "recording",
+        description: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        auto_save: bool = False,
+        save_path: Optional[str] = None,
+    ):
+        """
+        Initialize a recording session.
+
+        Args:
+            driver: Robot driver to record
+            name: Human-readable name for the recording
+            description: Optional description
+            tags: Optional tags for categorization
+            auto_save: If True, save automatically on exit
+            save_path: Path for auto-save (uses name if not provided)
+        """
+        self._driver = driver
+        self._name = name
+        self._description = description
+        self._tags = tags or []
+        self._auto_save = auto_save
+        self._save_path = save_path
+
+        self._calls: List[RecordedCall] = []
+        self._start_time: Optional[float] = None
+        self._end_time: Optional[float] = None
+        self._original_methods: Dict[str, Callable] = {}
+        self._recording = False
+
+    @property
+    def calls(self) -> List[RecordedCall]:
+        """Get all recorded calls."""
+        return self._calls.copy()
+
+    @property
+    def duration(self) -> Optional[float]:
+        """Get recording duration in seconds."""
+        if self._start_time is None:
+            return None
+        end = self._end_time or time.time()
+        return end - self._start_time
+
+    @property
+    def is_recording(self) -> bool:
+        """Check if currently recording."""
+        return self._recording
+
+    def __enter__(self) -> "RecordingSession":
+        """Start recording."""
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Stop recording."""
+        self.stop()
+        if self._auto_save:
+            path = self._save_path or f"{self._name}.demonstration"
+            self.save(path)
+        return False  # Don't suppress exceptions
+
+    def start(self) -> None:
+        """Start recording interface calls."""
+        if self._recording:
+            return
+
+        self._start_time = time.time()
+        self._recording = True
+        self._wrap_driver_methods()
+
+    def stop(self) -> None:
+        """Stop recording interface calls."""
+        if not self._recording:
+            return
+
+        self._end_time = time.time()
+        self._recording = False
+        self._unwrap_driver_methods()
+
+    def _wrap_driver_methods(self) -> None:
+        """Wrap all driver methods to intercept calls."""
+        # Get all interfaces the driver implements
+        interfaces = self._get_driver_interfaces()
+
+        for interface_name, interface_cls in interfaces.items():
+            # Get methods defined in this interface
+            for method_name in self._get_interface_methods(interface_cls):
+                if hasattr(self._driver, method_name):
+                    original = getattr(self._driver, method_name)
+                    if callable(original) and not method_name.startswith('_'):
+                        # Store original
+                        key = f"{interface_name}.{method_name}"
+                        self._original_methods[key] = original
+
+                        # Create wrapper
+                        wrapper = self._create_wrapper(interface_name, method_name, original)
+                        setattr(self._driver, method_name, wrapper)
+
+    def _unwrap_driver_methods(self) -> None:
+        """Restore original driver methods."""
+        for key, original in self._original_methods.items():
+            _, method_name = key.split(".", 1)
+            setattr(self._driver, method_name, original)
+        self._original_methods.clear()
+
+    def _get_driver_interfaces(self) -> Dict[str, type]:
+        """Get all interface classes the driver implements."""
+        from ate.interfaces import (
+            RobotInterface, SafetyInterface,
+            QuadrupedLocomotion, BipedLocomotion, WheeledLocomotion, AerialLocomotion,
+            ArmInterface, GripperInterface, DualArmInterface,
+            CameraInterface, DepthCameraInterface, LidarInterface, IMUInterface, ForceTorqueInterface,
+            BodyPoseInterface,
+        )
+
+        all_interfaces = {
+            "RobotInterface": RobotInterface,
+            "SafetyInterface": SafetyInterface,
+            "QuadrupedLocomotion": QuadrupedLocomotion,
+            "BipedLocomotion": BipedLocomotion,
+            "WheeledLocomotion": WheeledLocomotion,
+            "AerialLocomotion": AerialLocomotion,
+            "ArmInterface": ArmInterface,
+            "GripperInterface": GripperInterface,
+            "DualArmInterface": DualArmInterface,
+            "CameraInterface": CameraInterface,
+            "DepthCameraInterface": DepthCameraInterface,
+            "LidarInterface": LidarInterface,
+            "IMUInterface": IMUInterface,
+            "ForceTorqueInterface": ForceTorqueInterface,
+            "BodyPoseInterface": BodyPoseInterface,
+        }
+
+        return {
+            name: cls for name, cls in all_interfaces.items()
+            if isinstance(self._driver, cls)
+        }
+
+    def _get_interface_methods(self, interface_cls: type) -> List[str]:
+        """Get public methods defined in an interface class."""
+        methods = []
+        for name in dir(interface_cls):
+            if not name.startswith('_'):
+                attr = getattr(interface_cls, name, None)
+                if callable(attr):
+                    methods.append(name)
+        return methods
+
+    def _create_wrapper(
+        self,
+        interface_name: str,
+        method_name: str,
+        original: Callable
+    ) -> Callable:
+        """Create a wrapper function that records the call."""
+
+        @wraps(original)
+        def wrapper(*args, **kwargs):
+            timestamp = time.time()
+            relative_time = timestamp - self._start_time
+
+            try:
+                result = original(*args, **kwargs)
+                success = True
+                error = None
+
+                # Check ActionResult for failure
+                if isinstance(result, ActionResult) and not result.success:
+                    error = result.error
+
+            except Exception as e:
+                result = None
+                success = False
+                error = str(e)
+                raise
+            finally:
+                # Record the call
+                call = RecordedCall(
+                    timestamp=timestamp,
+                    relative_time=relative_time,
+                    interface=interface_name,
+                    method=method_name,
+                    args=args,
+                    kwargs=kwargs,
+                    result=result,
+                    success=success,
+                    error=error,
+                )
+                self._calls.append(call)
+
+            return result
+
+        return wrapper
+
+    def get_metadata(self) -> RecordingMetadata:
+        """Get recording metadata."""
+        info = self._driver.get_info()
+        return RecordingMetadata(
+            id=str(uuid.uuid4()),
+            name=self._name,
+            robot_name=info.name,
+            robot_model=info.model,
+            robot_archetype=info.archetype,
+            capabilities=[c.name for c in info.capabilities],
+            start_time=self._start_time or 0,
+            end_time=self._end_time,
+            duration=self.duration,
+            description=self._description,
+            tags=self._tags,
+        )
+
+    def save(self, path: str) -> None:
+        """
+        Save recording to a file.
+
+        Args:
+            path: File path (should end with .demonstration)
+        """
+        data = {
+            "version": "1.0",
+            "metadata": self.get_metadata().to_dict(),
+            "calls": [call.to_dict() for call in self._calls],
+        }
+
+        with open(path, 'w') as f:
+            json.dump(data, f, indent=2)
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for API upload."""
+        return {
+            "version": "1.0",
+            "metadata": self.get_metadata().to_dict(),
+            "calls": [call.to_dict() for call in self._calls],
+        }
+
+    def summary(self) -> str:
+        """Get a human-readable summary of the recording."""
+        if not self._calls:
+            return "No calls recorded"
+
+        # Group by interface
+        by_interface: Dict[str, List[RecordedCall]] = {}
+        for call in self._calls:
+            if call.interface not in by_interface:
+                by_interface[call.interface] = []
+            by_interface[call.interface].append(call)
+
+        lines = [
+            f"Recording: {self._name}",
+            f"Duration: {self.duration:.2f}s" if self.duration else "Duration: N/A",
+            f"Total calls: {len(self._calls)}",
+            "",
+            "By interface:",
+        ]
+
+        for interface, calls in by_interface.items():
+            lines.append(f"  {interface}: {len(calls)} calls")
+            # Count by method
+            by_method: Dict[str, int] = {}
+            for call in calls:
+                by_method[call.method] = by_method.get(call.method, 0) + 1
+            for method, count in sorted(by_method.items()):
+                lines.append(f"    - {method}: {count}")
+
+        return "\n".join(lines)

ate/recording/upload.py

@@ -0,0 +1,304 @@
+"""
+Upload demonstrations to FoodforThought.
+
+Converts interface recordings to the FoodforThought telemetry format
+and uploads them as artifacts for labeling and training.
+"""
+
+import os
+import json
+import requests
+from datetime import datetime
+from typing import Optional, Dict, Any
+from pathlib import Path
+
+from .demonstration import Demonstration, load_demonstration
+from .session import RecordingSession
+
+
+# API configuration
+BASE_URL = os.getenv("ATE_API_URL", "https://www.kindly.fyi/api")
+CONFIG_FILE = Path.home() / ".ate" / "config.json"
+
+
+class DemonstrationUploader:
+    """
+    Uploads demonstrations to FoodforThought.
+
+    Handles authentication and converts the interface-based recording
+    format to the FoodforThought telemetry ingest format.
+    """
+
+    def __init__(
+        self,
+        base_url: str = BASE_URL,
+        api_key: Optional[str] = None,
+    ):
+        """
+        Initialize uploader.
+
+        Args:
+            base_url: FoodforThought API URL
+            api_key: API key (or set ATE_API_KEY env var)
+        """
+        self.base_url = base_url
+        self.headers = {
+            "Content-Type": "application/json",
+        }
+
+        token = None
+
+        # Try to load from config file first (device auth flow)
+        if CONFIG_FILE.exists():
+            try:
+                with open(CONFIG_FILE) as f:
+                    config = json.load(f)
+                    # Prefer access_token from device auth flow
+                    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 upload(
+        self,
+        demonstration: Demonstration,
+        project_id: Optional[str] = None,
+        skill_id: Optional[str] = None,
+        create_labeling_task: bool = False,
+    ) -> Dict[str, Any]:
+        """
+        Upload a demonstration to FoodforThought.
+
+        Args:
+            demonstration: Demonstration object to upload
+            project_id: Optional project ID to associate with
+            skill_id: Optional skill ID this demonstrates
+            create_labeling_task: Create a labeling task for annotation
+
+        Returns:
+            Response dict with artifactId and optional taskId
+        """
+        # Convert to telemetry ingest format
+        recording_data = self._convert_to_telemetry_format(
+            demonstration,
+            skill_id=skill_id,
+        )
+
+        if create_labeling_task:
+            recording_data["createLabelingTask"] = True
+
+        # Upload via telemetry ingest API
+        response = self._request("POST", "/telemetry/ingest", json=recording_data)
+
+        return {
+            "success": True,
+            "artifactId": response.get("data", {}).get("artifactId"),
+            "taskId": response.get("data", {}).get("taskId"),
+            "url": f"https://foodforthought.kindly.fyi/artifacts/{response.get('data', {}).get('artifactId', '')}",
+        }
+
+    def upload_file(
+        self,
+        path: str,
+        project_id: Optional[str] = None,
+        skill_id: Optional[str] = None,
+        create_labeling_task: bool = False,
+    ) -> Dict[str, Any]:
+        """
+        Upload a demonstration file to FoodforThought.
+
+        Args:
+            path: Path to .demonstration file
+            project_id: Optional project ID
+            skill_id: Optional skill ID
+            create_labeling_task: Create labeling task
+
+        Returns:
+            Response dict with artifactId
+        """
+        demonstration = load_demonstration(path)
+        return self.upload(
+            demonstration,
+            project_id=project_id,
+            skill_id=skill_id,
+            create_labeling_task=create_labeling_task,
+        )
+
+    def upload_session(
+        self,
+        session: RecordingSession,
+        project_id: Optional[str] = None,
+        skill_id: Optional[str] = None,
+        create_labeling_task: bool = False,
+    ) -> Dict[str, Any]:
+        """
+        Upload a recording session directly to FoodforThought.
+
+        Args:
+            session: RecordingSession to upload
+            project_id: Optional project ID
+            skill_id: Optional skill ID
+            create_labeling_task: Create labeling task
+
+        Returns:
+            Response dict with artifactId
+        """
+        # Convert session to demonstration
+        metadata = session.get_metadata()
+        demonstration = Demonstration(
+            metadata=metadata,
+            calls=session.calls,
+            segments=[],
+        )
+
+        return self.upload(
+            demonstration,
+            project_id=project_id,
+            skill_id=skill_id,
+            create_labeling_task=create_labeling_task,
+        )
+
+    def _convert_to_telemetry_format(
+        self,
+        demonstration: Demonstration,
+        skill_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Convert demonstration to FoodforThought telemetry ingest format.
+
+        The telemetry format is designed for time-series data from robots.
+        We map interface calls to this format while preserving the
+        abstract nature of the recording.
+        """
+        metadata = demonstration.metadata
+
+        # Convert calls to telemetry frames
+        frames = []
+        for call in demonstration.calls:
+            frame = {
+                "timestamp": call.timestamp,
+                "relativeTime": call.relative_time,
+                "type": "interface_call",
+                "data": {
+                    "interface": call.interface,
+                    "method": call.method,
+                    "args": call.args,
+                    "kwargs": call.kwargs,
+                    "result": call.result,
+                    "success": call.success,
+                },
+            }
+            if call.error:
+                frame["data"]["error"] = call.error
+            frames.append(frame)
+
+        # Convert segments to events
+        events = []
+        for segment in demonstration.segments:
+            events.append({
+                "type": "task_segment",
+                "startTime": segment.start_time,
+                "endTime": segment.end_time,
+                "label": segment.label,
+                "description": segment.description,
+                "confidence": segment.confidence,
+            })
+
+        # Build recording data
+        start_time = datetime.fromtimestamp(metadata.start_time).isoformat() if metadata.start_time else None
+        end_time = datetime.fromtimestamp(metadata.end_time).isoformat() if metadata.end_time else None
+
+        recording_data = {
+            "recording": {
+                "id": metadata.id,
+                "robotId": metadata.robot_model,
+                "skillId": skill_id or "demonstration",
+                "source": "interface_recording",
+                "startTime": start_time,
+                "endTime": end_time,
+                "success": all(c.success for c in demonstration.calls),
+                "metadata": {
+                    "name": metadata.name,
+                    "description": metadata.description,
+                    "robotName": metadata.robot_name,
+                    "robotModel": metadata.robot_model,
+                    "robotArchetype": metadata.robot_archetype,
+                    "capabilities": metadata.capabilities,
+                    "duration": metadata.duration,
+                    "callCount": len(demonstration.calls),
+                    "segmentCount": len(demonstration.segments),
+                    "interfacesUsed": demonstration.get_interfaces_used(),
+                    "tags": metadata.tags + ["interface_recording"],
+                },
+                "frames": frames,
+                "events": events,
+            },
+        }
+
+        return recording_data
+
+
+def upload_demonstration(
+    path_or_demonstration,
+    project_id: Optional[str] = None,
+    skill_id: Optional[str] = None,
+    create_labeling_task: bool = False,
+    api_key: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Convenience function to upload a demonstration.
+
+    Args:
+        path_or_demonstration: Path to .demonstration file or Demonstration object
+        project_id: Optional project ID
+        skill_id: Optional skill ID
+        create_labeling_task: Create labeling task
+        api_key: Optional API key
+
+    Returns:
+        Response dict with artifactId
+    """
+    uploader = DemonstrationUploader(api_key=api_key)
+
+    if isinstance(path_or_demonstration, str):
+        return uploader.upload_file(
+            path_or_demonstration,
+            project_id=project_id,
+            skill_id=skill_id,
+            create_labeling_task=create_labeling_task,
+        )
+    elif isinstance(path_or_demonstration, Demonstration):
+        return uploader.upload(
+            path_or_demonstration,
+            project_id=project_id,
+            skill_id=skill_id,
+            create_labeling_task=create_labeling_task,
+        )
+    elif isinstance(path_or_demonstration, RecordingSession):
+        return uploader.upload_session(
+            path_or_demonstration,
+            project_id=project_id,
+            skill_id=skill_id,
+            create_labeling_task=create_labeling_task,
+        )
+    else:
+        raise TypeError(f"Expected path, Demonstration, or RecordingSession, got {type(path_or_demonstration)}")