any4robot 0.1.0__tar.gz

any4robot-0.1.0/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: any4robot
+Version: 0.1.0
+Summary: Foundation dataset tooling for VLA model training
+Author: Any4Robot Contributors
+License-Expression: Apache-2.0
+Keywords: robotics,dataset,lerobot,vla,data-tools
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+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
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: vendor/lero/LICENSE
+Requires-Dist: pandas>=1.5.0
+Requires-Dist: pyarrow>=10.0.0
+Provides-Extra: gui
+Requires-Dist: matplotlib>=3.5.0; extra == "gui"
+Requires-Dist: opencv-python>=4.5.0; extra == "gui"
+Requires-Dist: Pillow>=8.0.0; extra == "gui"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Dynamic: license-file
+
+# Any4Robot
+
+`any4robot` provides dataset conversion and management utilities for training VLA / WM / VAM robot control models. Data preparation is crucial for robot model development. Any4Robot provides a standardized, verified way to produce the right data so you can focus on model design.
+
+## Install
+
+```bash
+pip install any4robot
+```
+
+## Quick start (LeRobot editor)
+
+```python
+from any4robot import LeRobotDatasetEditor
+
+editor = LeRobotDatasetEditor("/path/to/lerobot-dataset")
+editor.list_episodes(0, 5)
+editor.delete_episode(12, dry_run=True)
+```
+
+## Combine datasets
+
+```python
+from any4robot.combine import merge_lerobot_datasets
+
+merge_lerobot_datasets(
+    ["/path/to/dataset_a", "/path/to/dataset_b"],
+    "/path/to/output_dataset",
+)
+```
+
+## Quality check (LeRobot v2.1 layout)
+
+```python
+from any4robot.qualitycheck import validate_lerobot_v2_1
+
+result = validate_lerobot_v2_1("/path/to/lerobot-dataset")
+print(result)
+```
+
+## Modules
+
+- `any4robot.editing`: LeRobot dataset editing helpers (delete episode, copy episode, list episodes)
+- `any4robot.combine`: Merge multiple LeRobot datasets into a single dataset
+- `any4robot.qualitycheck`: Validate datasets (LeRobot v2.1 layout)
+- `any4robot.conversion`: Placeholder for future dataset conversion pipelines
+
+## Notes
+
+- The LeRobot editor code is copied from `vendor/lero` and organized under `any4robot/lerobot_editor`.
+- Optional GUI dependencies are available with `pip install any4robot[gui]`.

any4robot-0.1.0/any4robot/__init__.py

@@ -0,0 +1,11 @@
+"""Any4Robot: dataset tooling foundation for VLA training workflows."""
+
+from .lerobot import LeRobotDatasetEditor, DatasetOperations, MetadataManager
+from .version import __version__
+
+__all__ = [
+    "LeRobotDatasetEditor",
+    "DatasetOperations",
+    "MetadataManager",
+    "__version__",
+]

any4robot-0.1.0/any4robot/combine/__init__.py

@@ -0,0 +1,33 @@
+"""Dataset combination utilities."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Dict, Iterable, Optional
+
+from any4robot.lerobot import DatasetOperations
+
+
+def merge_lerobot_datasets(
+    source_datasets: Iterable[str | Path],
+    output_path: str | Path,
+    task_mapping: Optional[Dict[str, str]] = None,
+    dry_run: bool = False,
+) -> bool:
+    """
+    Merge multiple LeRobot datasets into a single dataset.
+
+    This delegates to the LERO DatasetOperations merge implementation.
+    """
+    source_paths = [Path(p) for p in source_datasets]
+    output = Path(output_path)
+
+    if not source_paths:
+        raise ValueError("source_datasets must contain at least one dataset path")
+
+    # Use the first dataset path to bootstrap operations for merging.
+    ops = DatasetOperations(source_paths[0])
+    return ops.merge_datasets(source_paths, output, task_mapping=task_mapping, dry_run=dry_run)
+
+
+__all__ = ["merge_lerobot_datasets"]

any4robot-0.1.0/any4robot/conversion/__init__.py

@@ -0,0 +1,17 @@
+"""Conversion utilities (placeholder for future formats)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def convert_to_lerobot_v2_1(source_path: str | Path, output_path: str | Path, dry_run: bool = False) -> None:
+    """
+    Placeholder for converting datasets into LeRobot v2.1 format.
+
+    This function intentionally raises until a concrete converter is implemented.
+    """
+    raise NotImplementedError("Conversion pipeline is not yet implemented")
+
+
+__all__ = ["convert_to_lerobot_v2_1"]

any4robot-0.1.0/any4robot/editing/__init__.py

@@ -0,0 +1,5 @@
+"""Editing utilities for LeRobot datasets."""
+
+from any4robot.lerobot import LeRobotDatasetEditor
+
+__all__ = ["LeRobotDatasetEditor"]

any4robot-0.1.0/any4robot/formats/lerobot_v2_1.py

@@ -0,0 +1,108 @@
+"""LeRobot dataset v2.1 format validation helpers."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from any4robot.lerobot_editor.constants import (
+    DATA_DIR,
+    EPISODES_FILE,
+    INFO_FILE,
+    META_DIR,
+    TASKS_FILE,
+)
+from any4robot.lerobot_editor.file_utils import FileSystemManager
+
+
+REQUIRED_META_FILES = (INFO_FILE, EPISODES_FILE, TASKS_FILE)
+
+
+def _read_json(path: Path) -> Dict[str, Any]:
+    with path.open("r", encoding="utf-8") as handle:
+        return json.load(handle)
+
+
+def validate_lerobot_v2_1(dataset_path: str | Path, max_episodes: Optional[int] = None) -> Dict[str, Any]:
+    """
+    Validate a dataset against the LeRobot v2.1 directory layout.
+
+    Args:
+        dataset_path: Dataset root directory.
+        max_episodes: Optional cap on number of episodes to validate.
+    """
+    root = Path(dataset_path)
+    result: Dict[str, Any] = {
+        "valid": True,
+        "errors": [],
+        "warnings": [],
+        "checked_episodes": 0,
+        "dataset_path": str(root),
+    }
+
+    if not root.exists():
+        result["valid"] = False
+        result["errors"].append(f"Dataset path does not exist: {root}")
+        return result
+
+    meta_path = root / META_DIR
+    data_path = root / DATA_DIR
+
+    if not meta_path.exists():
+        result["valid"] = False
+        result["errors"].append(f"Missing meta directory: {meta_path}")
+        return result
+
+    missing_meta = [name for name in REQUIRED_META_FILES if not (meta_path / name).exists()]
+    if missing_meta:
+        result["valid"] = False
+        for name in missing_meta:
+            result["errors"].append(f"Missing meta file: {meta_path / name}")
+        return result
+
+    if not data_path.exists():
+        result["valid"] = False
+        result["errors"].append(f"Missing data directory: {data_path}")
+        return result
+
+    try:
+        info = _read_json(meta_path / INFO_FILE)
+    except Exception as exc:
+        result["valid"] = False
+        result["errors"].append(f"Failed to read info.json: {exc}")
+        return result
+
+    if "features" not in info:
+        result["warnings"].append("info.json missing 'features' field")
+
+    manager = FileSystemManager(root)
+    video_features = info.get("features", {})
+    episodes_path = meta_path / EPISODES_FILE
+
+    with episodes_path.open("r", encoding="utf-8") as handle:
+        for line in handle:
+            if not line.strip():
+                continue
+            episode = json.loads(line)
+            episode_index = episode.get("episode_index")
+
+            if episode_index is None:
+                result["valid"] = False
+                result["errors"].append("Episode entry missing episode_index")
+                break
+
+            paths = manager.get_episode_file_paths(int(episode_index), video_features)
+            if not paths["data"].exists():
+                result["valid"] = False
+                result["errors"].append(f"Missing data file for episode {episode_index}: {paths['data']}")
+                break
+
+            result["checked_episodes"] += 1
+            if max_episodes and result["checked_episodes"] >= max_episodes:
+                break
+
+    return result
+
+
+__all__ = ["validate_lerobot_v2_1"]

any4robot-0.1.0/any4robot/gui/__init__.py

@@ -0,0 +1,40 @@
+"""
+GUI module for LERO - LeRobot dataset Operations toolkit
+
+This module provides GUI components for viewing and editing LeRobot datasets.
+"""
+
+try:
+    from .viewer import EpisodeGUIViewer, launch_episode_viewer
+    from . import viewer
+    from . import video_component
+    from . import plot_component
+    from . import controls
+    from . import data_handler
+
+    # Create aliases for backward compatibility and test expectations
+    video_component.VideoComponent = video_component.VideoDisplayComponent
+    plot_component.PlotComponent = plot_component.JointPlotComponent
+
+    __all__ = [
+        'EpisodeGUIViewer', 
+        'launch_episode_viewer',
+        'viewer',
+        'video_component', 
+        'plot_component',
+        'controls',
+        'data_handler'
+    ]
+    
+except ImportError as e:
+    # GUI dependencies not available
+    error_message = f"GUI dependencies not available: {e}"
+    
+    def launch_episode_viewer(*args, **kwargs):
+        raise ImportError(error_message)
+    
+    class EpisodeGUIViewer:
+        def __init__(self, *args, **kwargs):
+            raise ImportError(error_message)
+    
+    __all__ = ['EpisodeGUIViewer', 'launch_episode_viewer']

any4robot-0.1.0/any4robot/gui/constants.py

@@ -0,0 +1,55 @@
+"""
+Constants and configuration for the GUI components.
+"""
+
+# GUI Layout Constants
+WINDOW_WIDTH = 1400
+WINDOW_HEIGHT = 900
+MAX_VIDEO_SIZE = 300
+
+# Playback Constants
+DEFAULT_PLAYBACK_SPEED = 1.0
+MIN_PLAYBACK_SPEED = 0.1
+MAX_PLAYBACK_SPEED = 10.0
+BASE_FPS = 60  # Target FPS for playback
+MIN_DELAY_MS = 1  # Minimum delay between frames in milliseconds
+VIDEO_UPDATE_SPEED_THRESHOLD = 2.0  # Skip video updates above this speed
+
+# Font Settings
+DEFAULT_FONT_SIZE = 12
+LABEL_FONT = ('TkDefaultFont', 12, 'bold')
+PLOT_TITLE_FONT_SIZE = 14
+PLOT_LABEL_FONT_SIZE = 12
+PLOT_TICK_FONT_SIZE = 10
+LEGEND_FONT_SIZE = 10
+
+# Robot Joint Constants
+SO100_JOINT_NAMES = [
+    'main_shoulder_pan', 
+    'main_shoulder_lift', 
+    'main_elbow_flex',
+    'main_wrist_flex', 
+    'main_wrist_roll', 
+    'main_gripper'
+]
+
+MAX_JOINTS_DISPLAY = 6
+
+# Plot Colors for Joint Angles
+JOINT_COLORS = [
+    '#1f77b4',  # Blue
+    '#ff7f0e',  # Orange
+    '#2ca02c',  # Green
+    '#d62728',  # Red
+    '#9467bd',  # Purple
+    '#8c564b'   # Brown
+]
+
+# UI Icons/Emojis
+ICON_CHART = "📊"
+ICON_TARGET = "🎯"
+ICON_FILM = "🎬"
+
+# Data Extraction Keywords
+JOINT_KEYWORDS = ['joint', 'position', 'angle', 'state']
+NUMERIC_DTYPES = ['float64', 'float32', 'int64', 'int32']

any4robot-0.1.0/any4robot/gui/controls.py

@@ -0,0 +1,265 @@
+"""
+Control panel components for the GUI.
+"""
+
+import tkinter as tk
+from tkinter import ttk
+from typing import Callable, Optional
+from .constants import (
+    MIN_PLAYBACK_SPEED, 
+    MAX_PLAYBACK_SPEED, 
+    DEFAULT_PLAYBACK_SPEED,
+    LABEL_FONT
+)
+
+
+class ControlPanel:
+    """Main control panel containing episode selection and playback controls."""
+    
+    def __init__(self, parent_frame: ttk.Frame, total_episodes: int):
+        """
+        Initialize the control panel.
+        
+        Args:
+            parent_frame: Parent frame to contain controls
+            total_episodes: Total number of episodes in dataset
+        """
+        self.parent_frame = parent_frame
+        self.total_episodes = total_episodes
+        
+        # Control variables
+        self.episode_var = tk.StringVar()
+        self.episode_info_var = tk.StringVar()
+        self.frame_var = tk.StringVar()
+        self.speed_var = tk.DoubleVar(value=DEFAULT_PLAYBACK_SPEED)
+        
+        # Control widgets
+        self.play_button: Optional[ttk.Button] = None
+        self.speed_label: Optional[ttk.Label] = None
+        
+        # Callbacks (to be set by parent)
+        self.on_load_episode: Optional[Callable] = None
+        self.on_toggle_playback: Optional[Callable] = None
+        self.on_stop_playback: Optional[Callable] = None
+        self.on_step_forward: Optional[Callable] = None
+        self.on_step_backward: Optional[Callable] = None
+        self.on_speed_change: Optional[Callable] = None
+        
+        self._setup_controls()
+    
+    def _setup_controls(self) -> None:
+        """Setup all control widgets."""
+        control_frame = ttk.LabelFrame(self.parent_frame, text="Controls", padding=10)
+        control_frame.pack(fill=tk.X, pady=(0, 10))
+        
+        self._setup_episode_controls(control_frame)
+        self._setup_playback_controls(control_frame)
+    
+    def _setup_episode_controls(self, parent: ttk.Frame) -> None:
+        """Setup episode selection controls."""
+        episode_frame = ttk.Frame(parent)
+        episode_frame.pack(fill=tk.X, pady=(0, 5))
+        
+        # Episode selection
+        ttk.Label(episode_frame, text="Episode:").pack(side=tk.LEFT)
+        
+        episode_spinbox = ttk.Spinbox(
+            episode_frame,
+            from_=0,
+            to=max(0, self.total_episodes - 1),
+            textvariable=self.episode_var,
+            width=10,
+            command=self._on_episode_spinbox_change
+        )
+        episode_spinbox.pack(side=tk.LEFT, padx=(5, 10))
+        
+        ttk.Button(
+            episode_frame,
+            text="Load Episode",
+            command=self._on_load_episode_button
+        ).pack(side=tk.LEFT)
+        
+        # Episode info display
+        episode_info_label = ttk.Label(
+            episode_frame, 
+            textvariable=self.episode_info_var, 
+            font=LABEL_FONT
+        )
+        episode_info_label.pack(side=tk.LEFT, padx=(20, 0))
+    
+    def _setup_playback_controls(self, parent: ttk.Frame) -> None:
+        """Setup playback control widgets."""
+        playback_frame = ttk.Frame(parent)
+        playback_frame.pack(fill=tk.X, pady=(5, 0))
+        
+        # Playback buttons
+        self.play_button = ttk.Button(
+            playback_frame,
+            text="Play",
+            command=self._on_toggle_playback_button
+        )
+        self.play_button.pack(side=tk.LEFT)
+        
+        ttk.Button(
+            playback_frame,
+            text="Stop",
+            command=self._on_stop_playback_button
+        ).pack(side=tk.LEFT, padx=(5, 0))
+        
+        ttk.Button(
+            playback_frame,
+            text="Step Back",
+            command=self._on_step_backward_button
+        ).pack(side=tk.LEFT, padx=(5, 0))
+        
+        ttk.Button(
+            playback_frame,
+            text="Step Forward",
+            command=self._on_step_forward_button
+        ).pack(side=tk.LEFT, padx=(5, 0))
+        
+        # Speed control
+        self._setup_speed_control(playback_frame)
+        
+        # Frame info display
+        frame_info_label = ttk.Label(
+            playback_frame, 
+            textvariable=self.frame_var, 
+            font=LABEL_FONT
+        )
+        frame_info_label.pack(side=tk.RIGHT)
+    
+    def _setup_speed_control(self, parent: ttk.Frame) -> None:
+        """Setup speed control widgets."""
+        ttk.Label(parent, text="Speed:").pack(side=tk.LEFT, padx=(20, 5))
+        
+        speed_scale = ttk.Scale(
+            parent,
+            from_=MIN_PLAYBACK_SPEED,
+            to=MAX_PLAYBACK_SPEED,
+            variable=self.speed_var,
+            orient=tk.HORIZONTAL,
+            length=120,
+            command=self._on_speed_scale_change
+        )
+        speed_scale.pack(side=tk.LEFT)
+        
+        self.speed_label = ttk.Label(parent, text="1.0x")
+        self.speed_label.pack(side=tk.LEFT, padx=(5, 0))
+    
+    # Callback wrappers
+    def _on_episode_spinbox_change(self):
+        """Handle episode spinbox change."""
+        pass  # Called by spinbox, but we use the button instead
+    
+    def _on_load_episode_button(self):
+        """Handle load episode button click."""
+        if self.on_load_episode:
+            self.on_load_episode()
+    
+    def _on_toggle_playback_button(self):
+        """Handle play/pause button click."""
+        if self.on_toggle_playback:
+            self.on_toggle_playback()
+    
+    def _on_stop_playback_button(self):
+        """Handle stop button click."""
+        if self.on_stop_playback:
+            self.on_stop_playback()
+    
+    def _on_step_forward_button(self):
+        """Handle step forward button click."""
+        if self.on_step_forward:
+            self.on_step_forward()
+    
+    def _on_step_backward_button(self):
+        """Handle step backward button click."""
+        if self.on_step_backward:
+            self.on_step_backward()
+    
+    def _on_speed_scale_change(self, value):
+        """Handle speed scale change."""
+        if self.on_speed_change:
+            self.on_speed_change(value)
+    
+    # Public methods for updating display
+    def update_play_button_text(self, text: str) -> None:
+        """Update the play button text."""
+        if self.play_button:
+            self.play_button.configure(text=text)
+    
+    def update_speed_display(self, speed_text: str) -> None:
+        """Update the speed display label."""
+        if self.speed_label:
+            self.speed_label.configure(text=speed_text)
+    
+    def update_episode_info(self, info_text: str) -> None:
+        """Update the episode information display."""
+        self.episode_info_var.set(info_text)
+    
+    def update_frame_info(self, frame_text: str) -> None:
+        """Update the frame information display."""
+        self.frame_var.set(frame_text)
+    
+    def get_episode_index(self) -> int:
+        """Get the currently selected episode index."""
+        try:
+            return int(self.episode_var.get())
+        except ValueError:
+            return 0
+    
+    def get_playback_speed(self) -> float:
+        """Get the current playback speed."""
+        return self.speed_var.get()
+
+
+class TimelineComponent:
+    """Timeline scrubber component for frame navigation."""
+    
+    def __init__(self, parent_frame: ttk.Frame):
+        """
+        Initialize the timeline component.
+        
+        Args:
+            parent_frame: Parent frame to contain the timeline
+        """
+        self.parent_frame = parent_frame
+        self.timeline_scale: Optional[ttk.Scale] = None
+        self.on_timeline_change: Optional[Callable] = None
+        
+        self._setup_timeline()
+    
+    def _setup_timeline(self) -> None:
+        """Setup the timeline scrubber."""
+        timeline_frame = ttk.LabelFrame(self.parent_frame, text="Timeline", padding=10)
+        timeline_frame.pack(fill=tk.X, pady=(10, 0))
+        
+        self.timeline_scale = ttk.Scale(
+            timeline_frame,
+            from_=0,
+            to=100,
+            orient=tk.HORIZONTAL,
+            command=self._on_timeline_scale_change
+        )
+        self.timeline_scale.pack(fill=tk.X)
+    
+    def _on_timeline_scale_change(self, value):
+        """Handle timeline scale change."""
+        if self.on_timeline_change:
+            self.on_timeline_change(value)
+    
+    def set_range(self, max_frame: int) -> None:
+        """Set the maximum range of the timeline."""
+        if self.timeline_scale:
+            self.timeline_scale.configure(to=max_frame)
+    
+    def set_position(self, frame: int) -> None:
+        """Set the current position of the timeline."""
+        if self.timeline_scale:
+            self.timeline_scale.set(frame)
+    
+    def get_position(self) -> float:
+        """Get the current position of the timeline."""
+        if self.timeline_scale:
+            return self.timeline_scale.get()
+        return 0.0