foodforthought-cli 0.2.0__py3-none-any.whl → 0.2.3__py3-none-any.whl

ate/telemetry/types.py

@@ -0,0 +1,334 @@
+"""
+Telemetry data types for FoodforThought
+
+Defines the core data structures for trajectory recording, sensor data,
+and execution events.
+"""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Dict, List, Optional, Any, Union
+from enum import Enum
+
+
+class TelemetrySource(str, Enum):
+    """Source of telemetry data"""
+    SIMULATION = "simulation"
+    HARDWARE = "hardware"
+    FLEET = "fleet"
+
+
+class EventType(str, Enum):
+    """Types of execution events"""
+    SKILL_START = "skill_start"
+    SKILL_END = "skill_end"
+    CONTACT = "contact"
+    ERROR = "error"
+    RECOVERY = "recovery"
+    USER_INTERVENTION = "user_intervention"
+    WAYPOINT_REACHED = "waypoint_reached"
+    GRASP = "grasp"
+    RELEASE = "release"
+
+
+class SensorType(str, Enum):
+    """Types of sensor readings"""
+    FORCE = "force"
+    TORQUE = "torque"
+    IMU = "imu"
+    CAMERA = "camera"
+    LIDAR = "lidar"
+    PROXIMITY = "proximity"
+    TEMPERATURE = "temperature"
+    CURRENT = "current"
+
+
+@dataclass
+class Vector3:
+    """3D vector for positions and forces"""
+    x: float = 0.0
+    y: float = 0.0
+    z: float = 0.0
+
+    def to_dict(self) -> Dict[str, float]:
+        return {"x": self.x, "y": self.y, "z": self.z}
+
+    def to_list(self) -> List[float]:
+        return [self.x, self.y, self.z]
+
+    @classmethod
+    def from_list(cls, data: List[float]) -> "Vector3":
+        return cls(x=data[0], y=data[1], z=data[2] if len(data) > 2 else 0.0)
+
+
+@dataclass
+class Quaternion:
+    """Quaternion for orientations (w, x, y, z)"""
+    x: float = 0.0
+    y: float = 0.0
+    z: float = 0.0
+    w: float = 1.0
+
+    def to_dict(self) -> Dict[str, float]:
+        return {"x": self.x, "y": self.y, "z": self.z, "w": self.w}
+
+    def to_list(self) -> List[float]:
+        return [self.x, self.y, self.z, self.w]
+
+    @classmethod
+    def from_list(cls, data: List[float]) -> "Quaternion":
+        return cls(x=data[0], y=data[1], z=data[2], w=data[3])
+
+
+@dataclass
+class Pose:
+    """6-DOF pose with position and orientation"""
+    position: Vector3 = field(default_factory=Vector3)
+    orientation: Quaternion = field(default_factory=Quaternion)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "position": self.position.to_dict(),
+            "orientation": self.orientation.to_dict(),
+        }
+
+    def to_flat_list(self) -> List[float]:
+        """Returns [x, y, z, qx, qy, qz, qw]"""
+        return self.position.to_list() + self.orientation.to_list()
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Pose":
+        pos = data.get("position", {})
+        ori = data.get("orientation", {})
+        return cls(
+            position=Vector3(
+                x=pos.get("x", 0),
+                y=pos.get("y", 0),
+                z=pos.get("z", 0)
+            ),
+            orientation=Quaternion(
+                x=ori.get("x", 0),
+                y=ori.get("y", 0),
+                z=ori.get("z", 0),
+                w=ori.get("w", 1)
+            ),
+        )
+
+
+@dataclass
+class Contact:
+    """Contact information between robot and environment"""
+    body1: str  # Name of first body in contact
+    body2: str  # Name of second body in contact
+    position: Vector3 = field(default_factory=Vector3)
+    normal: Vector3 = field(default_factory=Vector3)
+    force: float = 0.0  # Contact force magnitude
+    penetration: float = 0.0
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "body1": self.body1,
+            "body2": self.body2,
+            "position": self.position.to_dict(),
+            "normal": self.normal.to_dict(),
+            "force": self.force,
+            "penetration": self.penetration,
+        }
+
+
+@dataclass
+class SensorReading:
+    """Individual sensor reading"""
+    timestamp: float  # Seconds from recording start
+    sensor_id: str
+    sensor_type: SensorType
+    data: Union[List[float], bytes]  # Raw sensor data or numeric values
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "timestamp": self.timestamp,
+            "sensorId": self.sensor_id,
+            "sensorType": self.sensor_type.value if isinstance(self.sensor_type, SensorType) else self.sensor_type,
+            "data": list(self.data) if isinstance(self.data, (list, tuple)) else None,
+        }
+
+
+@dataclass
+class TrajectoryFrame:
+    """Single frame of trajectory data"""
+    timestamp: float  # Seconds from recording start
+    joint_positions: Dict[str, float] = field(default_factory=dict)
+    joint_velocities: Dict[str, float] = field(default_factory=dict)
+    joint_torques: Dict[str, float] = field(default_factory=dict)
+    joint_accelerations: Dict[str, float] = field(default_factory=dict)
+    end_effector_pose: Optional[Pose] = None
+    contacts: List[Contact] = field(default_factory=list)
+    sensor_readings: Dict[str, float] = field(default_factory=dict)
+    control_inputs: Dict[str, float] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "timestamp": self.timestamp,
+            "jointPositions": self.joint_positions,
+            "jointVelocities": self.joint_velocities,
+            "jointTorques": self.joint_torques,
+            "jointAccelerations": self.joint_accelerations,
+            "endEffectorPose": self.end_effector_pose.to_dict() if self.end_effector_pose else None,
+            "contacts": [c.to_dict() for c in self.contacts],
+            "sensorReadings": self.sensor_readings,
+            "controlInputs": self.control_inputs,
+        }
+
+
+@dataclass
+class DomainRandomizationConfig:
+    """Configuration for domain randomization applied during recording"""
+    friction_range: Optional[tuple] = None
+    mass_range: Optional[tuple] = None
+    damping_range: Optional[tuple] = None
+    noise_scale: float = 0.0
+    visual_variations: bool = False
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "frictionRange": list(self.friction_range) if self.friction_range else None,
+            "massRange": list(self.mass_range) if self.mass_range else None,
+            "dampingRange": list(self.damping_range) if self.damping_range else None,
+            "noiseScale": self.noise_scale,
+            "visualVariations": self.visual_variations,
+        }
+
+
+@dataclass
+class TrajectoryMetadata:
+    """Metadata about a trajectory recording"""
+    duration: float = 0.0  # Total duration in seconds
+    frame_rate: float = 0.0  # Frames per second
+    total_frames: int = 0
+    skill_params: Optional[Dict[str, Any]] = None
+    environment_id: Optional[str] = None
+    domain_randomization: Optional[DomainRandomizationConfig] = None
+    robot_version: Optional[str] = None
+    urdf_hash: Optional[str] = None  # Hash of URDF for reproducibility
+    joint_names: List[str] = field(default_factory=list)
+    tags: List[str] = field(default_factory=list)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "duration": self.duration,
+            "frameRate": self.frame_rate,
+            "totalFrames": self.total_frames,
+            "skillParams": self.skill_params,
+            "environmentId": self.environment_id,
+            "domainRandomization": self.domain_randomization.to_dict() if self.domain_randomization else None,
+            "robotVersion": self.robot_version,
+            "urdfHash": self.urdf_hash,
+            "jointNames": self.joint_names,
+            "tags": self.tags,
+        }
+
+
+@dataclass
+class TrajectoryRecording:
+    """Complete trajectory recording with frames and metadata"""
+    id: str
+    robot_id: str
+    skill_id: Optional[str] = None
+    source: TelemetrySource = TelemetrySource.HARDWARE
+    start_time: Optional[datetime] = None
+    end_time: Optional[datetime] = None
+    success: bool = True
+    frames: List[TrajectoryFrame] = field(default_factory=list)
+    metadata: TrajectoryMetadata = field(default_factory=TrajectoryMetadata)
+    events: List["ExecutionEvent"] = field(default_factory=list)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "id": self.id,
+            "robotId": self.robot_id,
+            "skillId": self.skill_id,
+            "source": self.source.value if isinstance(self.source, TelemetrySource) else self.source,
+            "startTime": self.start_time.isoformat() if self.start_time else None,
+            "endTime": self.end_time.isoformat() if self.end_time else None,
+            "success": self.success,
+            "metadata": self.metadata.to_dict(),
+            "frameCount": len(self.frames),
+            "eventCount": len(self.events),
+        }
+
+
+@dataclass
+class ExecutionEvent:
+    """Event that occurred during skill execution"""
+    timestamp: float  # Seconds from recording start
+    event_type: EventType
+    data: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "timestamp": self.timestamp,
+            "eventType": self.event_type.value if isinstance(self.event_type, EventType) else self.event_type,
+            "data": self.data,
+        }
+
+
+@dataclass
+class TelemetryBuffer:
+    """Ring buffer for efficient telemetry storage"""
+    max_size: int = 36000  # 10 minutes at 60Hz
+    _frames: List[TrajectoryFrame] = field(default_factory=list, repr=False)
+    _events: List[ExecutionEvent] = field(default_factory=list, repr=False)
+    _head: int = 0
+    _count: int = 0
+
+    def add(self, frame: TrajectoryFrame) -> None:
+        """Add a frame to the buffer (ring buffer behavior)"""
+        if len(self._frames) < self.max_size:
+            self._frames.append(frame)
+        else:
+            self._frames[self._head] = frame
+        self._head = (self._head + 1) % self.max_size
+        self._count = min(self._count + 1, self.max_size)
+
+    def add_event(self, event: ExecutionEvent) -> None:
+        """Add an event (no ring buffer - events are rare)"""
+        self._events.append(event)
+
+    def get_all_frames(self) -> List[TrajectoryFrame]:
+        """Get all frames in chronological order"""
+        if len(self._frames) < self.max_size:
+            return self._frames[:]
+        # Ring buffer is full, need to reorder
+        return self._frames[self._head:] + self._frames[:self._head]
+
+    def get_all_events(self) -> List[ExecutionEvent]:
+        """Get all events"""
+        return self._events[:]
+
+    def flush(self) -> tuple:
+        """Return all data and clear buffer"""
+        frames = self.get_all_frames()
+        events = self.get_all_events()
+        self.clear()
+        return frames, events
+
+    def clear(self) -> None:
+        """Clear the buffer"""
+        self._frames = []
+        self._events = []
+        self._head = 0
+        self._count = 0
+
+    def is_empty(self) -> bool:
+        """Check if buffer is empty"""
+        return len(self._frames) == 0 and len(self._events) == 0
+
+    @property
+    def frame_count(self) -> int:
+        """Number of frames in buffer"""
+        return len(self._frames)
+
+    @property
+    def event_count(self) -> int:
+        """Number of events in buffer"""
+        return len(self._events)

foodforthought_cli-0.2.3.dist-info/METADATA

@@ -0,0 +1,300 @@
+Metadata-Version: 2.4
+Name: foodforthought-cli
+Version: 0.2.3
+Summary: CLI tool for FoodforThought robotics repository platform - manage robot skills and data
+Home-page: https://kindly.fyi/foodforthought
+Author: Kindly Robotics
+Author-email: hello@kindly.fyi
+Project-URL: Homepage, https://kindly.fyi
+Project-URL: Documentation, https://kindly.fyi/foodforthought/cli
+Project-URL: Source, https://github.com/kindlyrobotics/monorepo
+Project-URL: Bug Tracker, https://github.com/kindlyrobotics/monorepo/issues
+Keywords: robotics,robot-skills,machine-learning,data-management,cli
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Software Development :: Version Control
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28.0
+Provides-Extra: robot-setup
+Requires-Dist: pyserial>=3.5; extra == "robot-setup"
+Requires-Dist: anthropic>=0.18.0; extra == "robot-setup"
+Provides-Extra: all
+Requires-Dist: pyserial>=3.5; extra == "all"
+Requires-Dist: anthropic>=0.18.0; extra == "all"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# FoodforThought CLI
+
+GitHub-like CLI tool for the FoodforThought robotics repository platform.
+
+**Version**: 0.2.1  
+**PyPI**: https://pypi.org/project/foodforthought-cli/
+
+## Installation
+
+```bash
+pip install foodforthought-cli
+```
+
+Or install from source:
+
+```bash
+cd foodforthought-cli
+pip install -e .
+```
+
+## Configuration
+
+Set environment variables:
+
+```bash
+export ATE_API_URL="https://kindly.fyi/api"
+export ATE_API_KEY="your-api-key-here"
+```
+
+## Usage
+
+### Initialize a repository
+
+```bash
+ate init my-robot-skill -d "A skill for my robot" -v public
+```
+
+### Clone a repository
+
+```bash
+ate clone <repository-id>
+```
+
+### Create a commit
+
+```bash
+ate commit -m "Add new control algorithm"
+```
+
+### Push to remote
+
+```bash
+ate push -b main
+```
+
+### Deploy to robot
+
+```bash
+ate deploy unitree-r1
+```
+
+## Commands
+
+### Repository Management
+- `ate init <name>` - Initialize a new repository
+- `ate clone <repo-id>` - Clone a repository
+- `ate commit -m <message>` - Create a commit
+- `ate push [-b <branch>]` - Push commits to remote
+
+### Skill Pipeline
+- `ate pull <skill-id> [--robot <robot>] [--format json|rlds|lerobot] [--output ./data]` - Pull skill data for training
+- `ate upload <video-path> --robot <robot> --task <task> [--project <id>]` - Upload demonstrations for labeling
+- `ate check-transfer --from <source-robot> --to <target-robot> [--skill <id>]` - Check skill transfer compatibility
+- `ate labeling-status <job-id>` - Check labeling job status
+
+### Parts & Dependencies (New in v0.2.0)
+- `ate parts list [--category gripper]` - List available hardware parts
+- `ate parts check <skill-id>` - Check part compatibility for a skill
+- `ate parts require <part-id> --skill <skill-id>` - Add part dependency to a skill
+- `ate deps audit` - Verify all dependencies are compatible
+
+### Text-to-Skill Generation (New in v0.2.0)
+- `ate generate "<description>" --robot <robot> --output ./skill/` - Generate skill skeleton from natural language
+
+Example:
+```bash
+ate generate "pick up box and place on pallet" --robot franka-panda --output ./new-skill/
+```
+
+### Workflow Orchestration (New in v0.2.0)
+- `ate workflow validate <pipeline.yaml>` - Validate a workflow definition
+- `ate workflow run <pipeline.yaml> --sim` - Run workflow in simulation
+- `ate workflow export <pipeline.yaml> --format ros2` - Export to ROS2 launch format
+
+### Team Collaboration (New in v0.2.0)
+- `ate team create <name>` - Create a new team
+- `ate team invite <email> --role member` - Invite a member
+- `ate team list` - List teams and members
+- `ate skill share <skill-id> --team <team-slug>` - Share a skill with a team
+
+### Skill Compiler (New in v0.2.1)
+
+Compile skill.yaml specifications into deployable packages. See [docs/SKILL_COMPILER.md](docs/SKILL_COMPILER.md) for full documentation.
+
+```bash
+# Validate a skill specification
+ate validate-skill my_skill.skill.yaml
+
+# Compile to Python package
+ate compile my_skill.skill.yaml --target python --output ./dist
+
+# Compile to ROS2 package
+ate compile my_skill.skill.yaml --target ros2 --robot robots/ur5.urdf
+
+# Test the compiled skill
+ate test-skill ./dist --mode dry-run
+
+# Check robot compatibility
+ate check-compatibility my_skill.skill.yaml --robot-urdf robots/ur5.urdf
+
+# Publish to registry
+ate publish-skill ./dist --visibility public
+```
+
+**Quick Start for AI Assistants:**
+1. `ate_list_primitives` - Discover available building blocks
+2. `ate_validate_skill_spec` - Check skill.yaml for errors
+3. `ate_check_skill_compatibility` - Verify robot compatibility
+4. `ate_compile_skill` - Generate deployable code
+5. `ate_test_compiled_skill` - Test without a robot
+
+### Dataset Management (New in v0.2.0)
+- `ate data upload ./sensor-logs/ --skill <id> --stage raw` - Upload sensor data
+- `ate data list --skill <id> --stage annotated` - List datasets
+- `ate data promote <dataset-id> --to skill-abstracted` - Promote to next stage
+- `ate data export <dataset-id> --format rlds` - Export dataset
+
+### Deployment & Configuration (New in v0.2.0)
+- `ate deploy --config deploy.yaml --target fleet-alpha` - Deploy with config
+- `ate deploy status <fleet-name>` - Check deployment status
+
+### Deployment & Testing
+- `ate deploy <robot-type>` - Deploy to a robot (e.g., unitree-r1)
+- `ate test [-e gazebo|mujoco|pybullet|webots] [-r robot]` - Test skills in simulation
+- `ate benchmark [-t speed|accuracy|robustness|efficiency|all]` - Run performance benchmarks
+- `ate adapt <source-robot> <target-robot>` - Adapt skills between robots
+
+### Safety & Validation
+- `ate validate [-c collision|speed|workspace|force|all]` - Validate safety and compliance
+- `ate stream [start|stop|status] [-s sensors...]` - Stream sensor data
+
+## Cursor IDE Integration (MCP)
+
+FoodforThought CLI includes a full MCP (Model Context Protocol) server for integration with Cursor IDE.
+
+### Quick Install via Deep Link
+
+Click this link to install in Cursor:
+```
+cursor://anysphere.cursor-deeplink/mcp/install?name=foodforthought&config=eyJtY3BTZXJ2ZXJzIjogeyJmb29kZm9ydGhvdWdodCI6IHsiY29tbWFuZCI6ICJweXRob24iLCAiYXJncyI6IFsiLW0iLCAiYXRlLm1jcF9zZXJ2ZXIiXSwgImVudiI6IHsiQVRFX0FQSV9VUkwiOiAiaHR0cHM6Ly9raW5kbHkuZnlpL2FwaSJ9fX19
+```
+
+### Manual Installation
+
+1. Install the CLI:
+   ```bash
+   pip install foodforthought-cli
+   ```
+
+2. Install MCP SDK:
+   ```bash
+   pip install mcp
+   ```
+
+3. Add to your Cursor MCP config (`~/.cursor/mcp.json` or `.cursor/mcp.json`):
+   ```json
+   {
+     "mcpServers": {
+       "foodforthought": {
+         "command": "python",
+         "args": ["-m", "ate.mcp_server"],
+         "env": {
+           "ATE_API_URL": "https://kindly.fyi/api"
+         }
+       }
+     }
+   }
+   ```
+
+4. Restart Cursor
+
+### Available MCP Tools (37+)
+
+| Category | Tools |
+|----------|-------|
+| **Skill Compiler** | `ate_compile_skill`, `ate_validate_skill_spec`, `ate_test_compiled_skill`, `ate_publish_compiled_skill`, `ate_check_skill_compatibility` |
+| **Primitives** | `ate_list_primitives`, `ate_get_primitive` |
+| **Skills** | `ate_skills_list`, `ate_skills_create`, `ate_skills_get`, `ate_pull`, `ate_upload` |
+| **Testing** | `ate_test`, `ate_simulate` |
+| **Compatibility** | `ate_adapt`, `ate_compatibility_check` |
+| **Parts** | `ate_parts_list`, `ate_parts_check`, `ate_parts_require`, `ate_deps_audit` |
+| **Generation** | `ate_generate` |
+| **Workflows** | `ate_workflow_validate`, `ate_workflow_run`, `ate_workflow_export` |
+| **Teams** | `ate_team_create`, `ate_team_invite`, `ate_team_list`, `ate_team_share` |
+| **Datasets** | `ate_data_upload`, `ate_data_list`, `ate_data_promote`, `ate_data_export` |
+| **Deployment** | `ate_deploy`, `ate_deploy_status` |
+| **Audit** | `ate_audit_trail` |
+
+### MCP Resources
+
+- `skill://{id}` - Skill details and configuration
+- `part://{id}` - Hardware part specifications
+- `workflow://{id}` - Workflow definition
+- `team://{id}` - Team information
+- `deployment://{id}` - Deployment status
+- `audit://{id}` - Audit trail
+
+### MCP Prompts
+
+- `setup_workflow` - Guide for multi-skill workflows
+- `deploy_skill` - Step-by-step deployment guide
+- `debug_compatibility` - Debug skill transfer issues
+- `onboard_robot` - Add a new robot to the platform
+- `audit_deployment` - Generate audit reports
+
+See the [MCP Server Guide](../docs/MCP_SERVER_GUIDE.md) for full documentation.
+
+## CI/CD Integration
+
+### GitHub Actions
+
+Use the provided actions for CI/CD:
+
+```yaml
+name: Skill CI
+on: [push, pull_request]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: kindly-robotics/test-skill@v1
+        with:
+          skill-path: ./
+          robot-model: ur5
+      - uses: kindly-robotics/check-transfer@v1
+        with:
+          skill: .
+          min-score: 0.6
+```
+
+## License
+
+Copyright © 2024-2025 Kindly Robotics. All rights reserved.

foodforthought_cli-0.2.3.dist-info/RECORD

@@ -0,0 +1,44 @@
+ate/__init__.py,sha256=u_wReCsJRGB9lkTU10CCiIoq2bNj_4no5ouqEsKHkHM,105
+ate/bridge_server.py,sha256=FI9PSLzq_eW9JYUS_qzTHZ4NnOkIr7G7sdwTWSYaMnQ,21365
+ate/cli.py,sha256=kjGtQ0bD2UI9rHScBvqo6MljRLO7rDOo4lCIgfMWkAQ,176611
+ate/compatibility.py,sha256=K5pSpPVHLgPSIF-a6kIJrehI9wl5AH3Cx76rOFCUZ2k,23094
+ate/generator.py,sha256=DUPat3cmoe9ufPajHFoI5kK6tfvPtVtB9gLvTlJzPdU,18308
+ate/marketplace.py,sha256=oLZOm8GbOOuxvsB45836KiTW7lCI_wSfIh-VY6crlYA,17474
+ate/mcp_server.py,sha256=hMi2QFcgkxyZGRLbvn8YZwcN2lVPPE2VgjoZjb2lEdc,102256
+ate/primitives.py,sha256=mku_-ivbBiTth90ru6wLZg4by-f6Fkds4D9l6PrroFI,30390
+ate/robot_setup.py,sha256=5KNYHh2RSWy5Y9hA3F56HQYa7HD8Y7VLq3gcuNV-wnQ,91800
+ate/skill_schema.py,sha256=q5zOrYJV2FVR59cW5UN9OowHLxtnwstWMF1pa5XgvtE,17719
+ate/generators/__init__.py,sha256=8tVjL3FpiesAH6SaSAIlwP1ctlP5GBXbptUaOOGMuvI,544
+ate/generators/docker_generator.py,sha256=Q2ux-db_9AZfmogB4O0JL_0s0nv38JzTiSpOnkPEBqI,11779
+ate/generators/hardware_config.py,sha256=FU5ntIzpxPAVecgqRHKCOUdUoFYRwVc_kz9DinZRcXA,15986
+ate/generators/ros2_generator.py,sha256=Sx8GIoYhBCRuv0L9Y9QlZvgoR2GOGm5tCpGyGvG3YmY,19765
+ate/generators/skill_generator.py,sha256=WLNxM437bL0iXf4UlAXYstNI5RSmBhzFSGKQdfJsLAc,28631
+ate/telemetry/__init__.py,sha256=qNUnu4n33vJn53AfUVNvME0C8Fc4smUCmXOFsBHTtzs,669
+ate/telemetry/cli.py,sha256=-Jzp3HXkQsm9_Q0qQgt3HDzOMSqsZsPwycwV3eS2Gl0,15816
+ate/telemetry/collector.py,sha256=3A4JSa_d3XUaVPYi4SVHI1pgkPBh2KFhO56ToBhO8R4,15844
+ate/telemetry/context.py,sha256=km-b7ge31vbfN7HhFEErdCOkdXCEl-a9e6j5szqbziA,10429
+ate/telemetry/fleet_agent.py,sha256=iWKSXmnASumTArvO4ek7Wcv019dvnkJAdLH9spsKnSw,14260
+ate/telemetry/types.py,sha256=5kgwXGoQ-_kuD4gszlaXW7LN9L6lKmSyt4EOPeoZlSo,11066
+ate/telemetry/formats/__init__.py,sha256=a9ylB6nSJMbLIarBq60gEMpznHSs2d3JMY3uIeUt4F4,458
+ate/telemetry/formats/hdf5_serializer.py,sha256=RgACw9S8J5ZRkj1GML0ib4k0WHWx30TAemIw-Nko1l8,18703
+ate/telemetry/formats/mcap_serializer.py,sha256=7wsDzguseApTO6G58nFM4Jp-mTWzy5IaTZCKzpUs0-U,14396
+mechdog_labeled/__init__.py,sha256=qIrQzLk38jm9kfGtyqVHEuBNE-ljz3v3P8jg7aIARF0,160
+mechdog_labeled/primitives.py,sha256=W9AtSjeTBy5gteEKS0NkZgogL1Hf2Etxsdd0hq6LRhs,3846
+mechdog_labeled/servo_map.py,sha256=p86iBqkBDa09JKVm_TWC1j42erOQMTb96eMHWZtdGf4,4543
+mechdog_output/__init__.py,sha256=qIrQzLk38jm9kfGtyqVHEuBNE-ljz3v3P8jg7aIARF0,160
+mechdog_output/primitives.py,sha256=msTdyL1z3sh4qQcP_Cr0yKzg9xAzZUod14FkLd5Aeww,1884
+mechdog_output/servo_map.py,sha256=hygFLlg8kHbmu3CJOQGey1kRTB8XpmPayA1byP4pVIA,3589
+test_autodetect/__init__.py,sha256=qIrQzLk38jm9kfGtyqVHEuBNE-ljz3v3P8jg7aIARF0,160
+test_autodetect/primitives.py,sha256=7em8nBqB8zG93R32F3R6pPs4-rdH4xs3koZN8OH33Gg,3783
+test_autodetect/servo_map.py,sha256=YzYuVN-zuBC9uWgD1lBhFpSRYSbxRtflvGI2Qspeer8,4724
+test_full_auto/__init__.py,sha256=qIrQzLk38jm9kfGtyqVHEuBNE-ljz3v3P8jg7aIARF0,160
+test_full_auto/primitives.py,sha256=W9AtSjeTBy5gteEKS0NkZgogL1Hf2Etxsdd0hq6LRhs,3846
+test_full_auto/servo_map.py,sha256=p86iBqkBDa09JKVm_TWC1j42erOQMTb96eMHWZtdGf4,4543
+test_smart_detect/__init__.py,sha256=qIrQzLk38jm9kfGtyqVHEuBNE-ljz3v3P8jg7aIARF0,160
+test_smart_detect/primitives.py,sha256=W9AtSjeTBy5gteEKS0NkZgogL1Hf2Etxsdd0hq6LRhs,3846
+test_smart_detect/servo_map.py,sha256=p86iBqkBDa09JKVm_TWC1j42erOQMTb96eMHWZtdGf4,4543
+foodforthought_cli-0.2.3.dist-info/METADATA,sha256=f-6CYpzBIRUGKIRmfr3MF1uhRJN_fTT8D4_K12NV3g4,9584
+foodforthought_cli-0.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+foodforthought_cli-0.2.3.dist-info/entry_points.txt,sha256=JSxWuXCbGllyHqVJpomP_BDlXYpiNglM9Mo6bEmQK1A,37
+foodforthought_cli-0.2.3.dist-info/top_level.txt,sha256=Q8RL26hnZ7yLJbGqHMbthsZJJRho-UvpOJAEtAG4NbI,84
+foodforthought_cli-0.2.3.dist-info/RECORD,,

foodforthought_cli-0.2.3.dist-info/top_level.txt

@@ -0,0 +1,6 @@
+ate
+mechdog_labeled
+mechdog_output
+test_autodetect
+test_full_auto
+test_smart_detect

mechdog_labeled/__init__.py

@@ -0,0 +1,3 @@
+"""Generated robot package for unnamed_robot."""
+from .servo_map import ServoID, SERVO_LIMITS, ALL_SERVOS
+from .primitives import PrimitiveSkills, ServoCommand