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

ate/interfaces/sensors.py

@@ -0,0 +1,247 @@
+"""
+Sensor interfaces for robot perception.
+
+These interfaces abstract different sensor types so behaviors
+can work across robots with different sensor configurations.
+
+Design principle: A behavior that needs distance sensing can use
+ANY implementation of DistanceSensorInterface - ultrasonic, lidar,
+depth camera, or even visual estimation.
+"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Optional, List, Tuple
+from enum import Enum, auto
+
+from .types import ActionResult
+
+
+class DistanceSensorType(Enum):
+    """Type of distance sensor."""
+    ULTRASONIC = auto()      # HC-SR04, etc.
+    INFRARED = auto()        # IR proximity
+    LIDAR_SINGLE = auto()    # Single-point lidar
+    LIDAR_2D = auto()        # 2D scanning lidar
+    DEPTH_CAMERA = auto()    # Depth camera center point
+    VISUAL_ESTIMATION = auto()  # Estimated from RGB camera
+
+
+@dataclass
+class DistanceReading:
+    """A distance measurement."""
+    distance: float          # Distance in meters
+    valid: bool = True       # Whether reading is valid
+    sensor_type: DistanceSensorType = DistanceSensorType.ULTRASONIC
+    timestamp: float = 0.0   # Seconds since epoch
+    confidence: float = 1.0  # Confidence in reading (0-1)
+
+    @classmethod
+    def invalid(cls) -> "DistanceReading":
+        """Create an invalid reading."""
+        return cls(distance=0.0, valid=False)
+
+
+class DistanceSensorInterface(ABC):
+    """
+    Interface for distance/proximity sensing.
+
+    Can be implemented by:
+    - Ultrasonic sensors (HC-SR04, etc.)
+    - IR proximity sensors
+    - Single-point lidar
+    - Depth camera (center pixel or ROI average)
+    - Visual estimation (object size in image)
+
+    This abstraction allows behaviors like "approach target" to work
+    on any robot with any distance sensing capability.
+
+    Example:
+        # Works with any implementation
+        sensor: DistanceSensorInterface = robot.get_distance_sensor()
+
+        while True:
+            reading = sensor.get_distance()
+            if reading.valid and reading.distance < 0.15:
+                robot.stop()
+                break
+            robot.walk_forward(speed=0.1)
+    """
+
+    @abstractmethod
+    def get_distance(self) -> DistanceReading:
+        """
+        Get current distance reading.
+
+        Returns:
+            DistanceReading with distance in meters
+        """
+        pass
+
+    @abstractmethod
+    def get_min_range(self) -> float:
+        """
+        Get minimum measurable range in meters.
+
+        Returns below this distance are unreliable.
+        """
+        pass
+
+    @abstractmethod
+    def get_max_range(self) -> float:
+        """
+        Get maximum measurable range in meters.
+
+        Returns above this distance are unreliable.
+        """
+        pass
+
+    def get_sensor_type(self) -> DistanceSensorType:
+        """Get the type of distance sensor."""
+        return DistanceSensorType.ULTRASONIC  # Default
+
+    def is_obstacle_detected(self, threshold: float = 0.20) -> bool:
+        """
+        Check if an obstacle is within threshold distance.
+
+        Args:
+            threshold: Distance threshold in meters
+
+        Returns:
+            True if obstacle detected within threshold
+        """
+        reading = self.get_distance()
+        return reading.valid and reading.distance < threshold
+
+
+class VisualDistanceEstimator(DistanceSensorInterface):
+    """
+    Estimate distance from visual object size.
+
+    When no hardware distance sensor is available, we can estimate
+    distance based on the apparent size of a detected object.
+
+    This uses the pinhole camera model:
+        distance = (known_size * focal_length) / apparent_size
+
+    For unknown objects, we use heuristics based on object category.
+    """
+
+    # Typical object sizes in meters (width)
+    TYPICAL_SIZES = {
+        "bottle": 0.07,
+        "can": 0.065,
+        "wrapper": 0.10,
+        "paper": 0.20,
+        "plastic": 0.10,
+        "metal": 0.08,
+        "unknown": 0.10,
+    }
+
+    def __init__(
+        self,
+        image_width: int = 640,
+        image_height: int = 480,
+        fov_horizontal: float = 60.0,  # Degrees
+    ):
+        """
+        Initialize visual distance estimator.
+
+        Args:
+            image_width: Camera image width in pixels
+            image_height: Camera image height in pixels
+            fov_horizontal: Horizontal field of view in degrees
+        """
+        self.image_width = image_width
+        self.image_height = image_height
+        self.fov_horizontal = fov_horizontal
+
+        # Calculate focal length in pixels
+        import math
+        self.focal_length = image_width / (2 * math.tan(math.radians(fov_horizontal / 2)))
+
+        self._last_reading: Optional[DistanceReading] = None
+
+    def estimate_from_detection(
+        self,
+        bbox_width: int,
+        object_type: str = "unknown",
+        known_size: Optional[float] = None,
+    ) -> DistanceReading:
+        """
+        Estimate distance from detected object bounding box.
+
+        Args:
+            bbox_width: Width of bounding box in pixels
+            object_type: Type of object (for size lookup)
+            known_size: Known real-world size in meters (overrides lookup)
+
+        Returns:
+            DistanceReading with estimated distance
+        """
+        import time
+
+        if bbox_width <= 0:
+            return DistanceReading.invalid()
+
+        # Get object size
+        real_size = known_size or self.TYPICAL_SIZES.get(object_type, 0.10)
+
+        # Estimate distance using pinhole model
+        distance = (real_size * self.focal_length) / bbox_width
+
+        # Confidence decreases with smaller bounding boxes (more uncertainty)
+        confidence = min(1.0, bbox_width / 50.0)
+
+        reading = DistanceReading(
+            distance=distance,
+            valid=True,
+            sensor_type=DistanceSensorType.VISUAL_ESTIMATION,
+            timestamp=time.time(),
+            confidence=confidence,
+        )
+
+        self._last_reading = reading
+        return reading
+
+    def get_distance(self) -> DistanceReading:
+        """Get last estimated distance."""
+        if self._last_reading:
+            return self._last_reading
+        return DistanceReading.invalid()
+
+    def get_min_range(self) -> float:
+        return 0.1  # 10cm minimum
+
+    def get_max_range(self) -> float:
+        return 5.0  # 5m maximum (very rough beyond this)
+
+    def get_sensor_type(self) -> DistanceSensorType:
+        return DistanceSensorType.VISUAL_ESTIMATION
+
+
+@dataclass
+class ProximitySensorReading:
+    """Reading from proximity/bump sensors."""
+    triggered: bool          # Whether sensor is triggered
+    sensor_id: str           # Sensor identifier
+    timestamp: float = 0.0
+
+
+class ProximitySensorInterface(ABC):
+    """
+    Interface for proximity/bump sensors.
+
+    These are simple binary sensors that detect contact or very close proximity.
+    Common on wheeled robots and robot vacuums.
+    """
+
+    @abstractmethod
+    def get_proximity_sensors(self) -> List[ProximitySensorReading]:
+        """Get readings from all proximity sensors."""
+        pass
+
+    @abstractmethod
+    def is_any_triggered(self) -> bool:
+        """Check if any proximity sensor is triggered."""
+        pass

ate/llm_proxy.py

@@ -0,0 +1,239 @@
+"""
+LLM Proxy - Routes AI requests through FoodforThought edge function.
+
+Benefits:
+- No API keys needed on client
+- Automatic usage metering per user
+- Rate limiting (50/week free, 500/week pro)
+- Billing integration via usage_logs table
+
+Usage:
+    from ate.llm_proxy import LLMProxy
+
+    proxy = LLMProxy()
+    response = proxy.chat(
+        messages=[{"role": "user", "content": "Hello"}],
+        model="claude-3-5-haiku-20241022",
+        max_tokens=150,
+    )
+"""
+
+import json
+from pathlib import Path
+from typing import Dict, Any, List, Optional
+from dataclasses import dataclass
+
+try:
+    import requests
+    HAS_REQUESTS = True
+except ImportError:
+    HAS_REQUESTS = False
+
+
+# Configuration
+EDGE_FUNCTION_URL = "https://tbkczrruqxopscwqxntr.supabase.co/functions/v1/chat-proxy"
+CONFIG_DIR = Path.home() / ".ate"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+
+@dataclass
+class LLMResponse:
+    """Parsed response from LLM."""
+    content: str
+    input_tokens: int
+    output_tokens: int
+    model: str
+    stop_reason: str
+
+
+class LLMProxyError(Exception):
+    """Error from LLM proxy."""
+    def __init__(self, message: str, status_code: Optional[int] = None, details: Optional[str] = None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.details = details
+
+
+class LLMProxy:
+    """
+    Proxy for LLM requests through FoodforThought edge function.
+
+    Handles authentication, rate limiting, and usage tracking automatically.
+    """
+
+    def __init__(self, access_token: Optional[str] = None):
+        """
+        Initialize proxy.
+
+        Args:
+            access_token: Optional auth token. If not provided, reads from CLI config.
+        """
+        if not HAS_REQUESTS:
+            raise ImportError("requests module required. Install with: pip install requests")
+
+        self.access_token = access_token or self._load_token()
+        self.base_url = EDGE_FUNCTION_URL
+
+    def _load_token(self) -> Optional[str]:
+        """Load access token from CLI config file."""
+        if not CONFIG_FILE.exists():
+            return None
+
+        try:
+            with open(CONFIG_FILE) as f:
+                config = json.load(f)
+                return config.get("access_token")
+        except Exception:
+            return None
+
+    def chat(
+        self,
+        messages: List[Dict[str, Any]],
+        model: str = "claude-3-5-haiku-20241022",
+        max_tokens: int = 1024,
+        temperature: float = 0.7,
+        system: Optional[str] = None,
+        stream: bool = False,
+    ) -> LLMResponse:
+        """
+        Send chat completion request through edge function.
+
+        Args:
+            messages: List of message dicts with 'role' and 'content'
+            model: Model to use (default: claude-3-5-haiku-20241022)
+            max_tokens: Maximum tokens in response
+            temperature: Sampling temperature
+            system: Optional system prompt
+            stream: Whether to stream (not yet supported)
+
+        Returns:
+            LLMResponse with content and token usage
+
+        Raises:
+            LLMProxyError: On API errors or auth issues
+        """
+        if stream:
+            raise NotImplementedError("Streaming not yet implemented in proxy")
+
+        # Build request
+        all_messages = []
+        if system:
+            all_messages.append({"role": "system", "content": system})
+        all_messages.extend(messages)
+
+        payload = {
+            "messages": all_messages,
+            "model": model,
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+            "stream": False,
+        }
+
+        headers = {
+            "Content-Type": "application/json",
+        }
+
+        # Add auth header if we have a token
+        if self.access_token:
+            headers["Authorization"] = f"Bearer {self.access_token}"
+        else:
+            raise LLMProxyError(
+                "Not authenticated. Run 'ate login' first.",
+                status_code=401,
+            )
+
+        # Make request
+        try:
+            response = requests.post(
+                self.base_url,
+                json=payload,
+                headers=headers,
+                timeout=60,
+            )
+        except requests.RequestException as e:
+            raise LLMProxyError(f"Request failed: {e}")
+
+        # Parse response
+        if response.status_code == 401:
+            raise LLMProxyError(
+                "Authentication failed. Try 'ate login' to re-authenticate.",
+                status_code=401,
+            )
+
+        if response.status_code == 402:
+            # Rate limit exceeded
+            data = response.json()
+            usage = data.get("usage", {})
+            raise LLMProxyError(
+                f"Rate limit exceeded: {usage.get('current', '?')}/{usage.get('limit', '?')} requests this week. "
+                f"Resets at {usage.get('resetsAt', 'next week')}. "
+                f"Upgrade at {data.get('upgrade_url', 'https://artifex.kindly.fyi/upgrade')}",
+                status_code=402,
+                details=json.dumps(data),
+            )
+
+        if response.status_code != 200:
+            try:
+                error_data = response.json()
+                error_msg = error_data.get("message") or error_data.get("error") or "Unknown error"
+                details = error_data.get("details")
+            except Exception:
+                error_msg = response.text or "Unknown error"
+                details = None
+
+            raise LLMProxyError(
+                f"LLM request failed: {error_msg}",
+                status_code=response.status_code,
+                details=details,
+            )
+
+        # Parse successful response (Anthropic format)
+        data = response.json()
+
+        # Extract content from Anthropic response format
+        content = ""
+        if "content" in data:
+            # Anthropic format: {"content": [{"type": "text", "text": "..."}]}
+            for block in data["content"]:
+                if block.get("type") == "text":
+                    content += block.get("text", "")
+        elif "choices" in data:
+            # OpenAI format
+            content = data["choices"][0]["message"]["content"]
+        else:
+            content = str(data)
+
+        # Extract usage
+        usage = data.get("usage", {})
+        input_tokens = usage.get("input_tokens", 0)
+        output_tokens = usage.get("output_tokens", 0)
+
+        return LLMResponse(
+            content=content,
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            model=data.get("model", model),
+            stop_reason=data.get("stop_reason", "unknown"),
+        )
+
+    def is_authenticated(self) -> bool:
+        """Check if we have a valid access token."""
+        return bool(self.access_token)
+
+
+def get_proxy() -> LLMProxy:
+    """
+    Get a configured LLM proxy instance.
+
+    Returns:
+        LLMProxy instance ready to use
+
+    Raises:
+        LLMProxyError: If not authenticated
+    """
+    proxy = LLMProxy()
+    if not proxy.is_authenticated():
+        raise LLMProxyError(
+            "Not authenticated. Run 'ate login' to authenticate with FoodforThought."
+        )
+    return proxy

ate/memory/__init__.py

@@ -0,0 +1,35 @@
+"""ATE Memory Library - Core memory operations with memvid-sdk backend."""
+
+from .store import MemoryStore
+from .search import SearchResult
+from .export import MemoryInfo
+from .merge import merge_memories
+from .embeddings import EmbeddingConfig, EmbeddingManager
+from .reranker import RerankConfig, LLMReranker
+from .context import ContextManager, MemoryContext, MemoryMetadata
+
+# Migration module imports
+from . import migrate
+from .migrate import (
+    VectorRecord,
+    MigrationEstimate,
+    MigrationResult,
+    MigrationCheckpoint,
+    MigrationSource,
+    MigrationPipeline,
+    PineconeMigrationSource,
+    QdrantMigrationSource,
+    WeaviateMigrationSource,
+    ChromaMigrationSource
+)
+
+__all__ = [
+    'MemoryStore', 'SearchResult', 'MemoryInfo', 'merge_memories',
+    'EmbeddingConfig', 'EmbeddingManager', 'RerankConfig', 'LLMReranker',
+    'ContextManager', 'MemoryContext', 'MemoryMetadata',
+    # Migration exports
+    'migrate', 'VectorRecord', 'MigrationEstimate', 'MigrationResult', 
+    'MigrationCheckpoint', 'MigrationSource', 'MigrationPipeline',
+    'PineconeMigrationSource', 'QdrantMigrationSource', 'WeaviateMigrationSource',
+    'ChromaMigrationSource'
+]