Upload 35 files

.gitattributes

@@ -53,3 +53,18 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.jpg filter=lfs diff=lfs merge=lfs -text
 *.jpeg filter=lfs diff=lfs merge=lfs -text
 *.webp filter=lfs diff=lfs merge=lfs -text
+v0.0.1/videos/cam_bottom_episode_1.mp4 filter=lfs diff=lfs merge=lfs -text
+v0.0.1/videos/cam_bottom_episode_2.mp4 filter=lfs diff=lfs merge=lfs -text
+v0.0.1/videos/cam_bottom_episode_3.mp4 filter=lfs diff=lfs merge=lfs -text
+v0.0.1/videos/cam_bottom_episode_4.mp4 filter=lfs diff=lfs merge=lfs -text
+v0.0.1/videos/cam_left_wrist_episode_1.mp4 filter=lfs diff=lfs merge=lfs -text
+v0.0.1/videos/cam_left_wrist_episode_2.mp4 filter=lfs diff=lfs merge=lfs -text
+v0.0.1/videos/cam_left_wrist_episode_4.mp4 filter=lfs diff=lfs merge=lfs -text
+v0.0.1/videos/cam_right_wrist_episode_1.mp4 filter=lfs diff=lfs merge=lfs -text
+v0.0.1/videos/cam_right_wrist_episode_2.mp4 filter=lfs diff=lfs merge=lfs -text
+v0.0.1/videos/cam_right_wrist_episode_3.mp4 filter=lfs diff=lfs merge=lfs -text
+v0.0.1/videos/cam_right_wrist_episode_4.mp4 filter=lfs diff=lfs merge=lfs -text
+v0.0.1/videos/cam_up_episode_1.mp4 filter=lfs diff=lfs merge=lfs -text
+v0.0.1/videos/cam_up_episode_2.mp4 filter=lfs diff=lfs merge=lfs -text
+v0.0.1/videos/cam_up_episode_3.mp4 filter=lfs diff=lfs merge=lfs -text
+v0.0.1/videos/cam_up_episode_4.mp4 filter=lfs diff=lfs merge=lfs -text

v0.0.1/aloha-client/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "aloha-client"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+
+serialport = "4.2.0"
+rustypot = { git = "https://github.com/haixuanTao/rustypot" }
+tokio = { version = "1.37.0", features = ["full"] }
+eyre = "0.6.12"
+dora-node-api = "0.3.3"

v0.0.1/aloha-client/src/main.rs

@@ -0,0 +1,59 @@
+use dora_node_api::{
+    arrow::array::UInt32Array, dora_core::config::DataId, DoraNode, Event, IntoArrow,
+};
+use eyre::Result;
+use rustypot::{device::xm, DynamixelSerialIO};
+use std::time::Duration;
+
+fn main() -> Result<()> {
+    let (mut node, mut events) = DoraNode::init_from_env()?;
+    let mut puppet_serial_port = serialport::new("/dev/ttyDXL_puppet_right", 1_000_000)
+        .timeout(Duration::from_millis(20))
+        .open()
+        .expect("Failed to open port");
+    let io = DynamixelSerialIO::v2();
+    xm::sync_write_torque_enable(
+        &io,
+        puppet_serial_port.as_mut(),
+        &[1, 2, 3, 4, 5, 6, 7, 8, 9],
+        &[1; 9],
+    )
+    .expect("Communication error");
+
+    while let Some(Event::Input {
+        id,
+        metadata: _,
+        data,
+    }) = events.recv()
+    {
+        match id.as_str() {
+            "puppet_goal_position" => {
+                let buffer: UInt32Array = data.to_data().into();
+                let target: &[u32] = buffer.values();
+                xm::sync_write_goal_position(
+                    &io,
+                    puppet_serial_port.as_mut(),
+                    &[1, 2, 3, 4, 5, 6, 7, 8, 9],
+                    &target,
+                )
+                .expect("Communication error");
+            }
+            "tick" => {
+                let pos = xm::sync_read_present_position(
+                    &io,
+                    puppet_serial_port.as_mut(),
+                    &[1, 2, 3, 4, 5, 6, 7, 8, 9],
+                )
+                .expect("Communication error");
+                node.send_output(
+                    DataId::from("puppet_position".to_owned()),
+                    Default::default(),
+                    pos.into_arrow(),
+                )?;
+            }
+            _ => todo!(),
+        };
+    }
+
+    Ok(())
+}

v0.0.1/aloha-teleop/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "aloha-teleop"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+
+serialport = "4.2.0"
+rustypot = { git = "https://github.com/haixuanTao/rustypot" }
+tokio = { version = "1.37.0", features = ["full"] }
+eyre = "0.6.12"
+clap = { version = "4.5.4", features = ["derive"] }
+dora-node-api = "0.3.3"

v0.0.1/aloha-teleop/src/main.rs

@@ -0,0 +1,126 @@
+use dora_node_api::{dora_core::config::DataId, DoraNode, IntoArrow, MetadataParameters};
+use eyre::{Context, Result};
+use rustypot::{device::xm, DynamixelSerialIO};
+use serialport::SerialPort;
+use std::{
+    sync::mpsc,
+    time::{Duration, Instant},
+};
+
+static MAX_MASTER_GRIPER: u32 = 2554;
+static MAX_PUPPET_GRIPER: u32 = 3145;
+
+static MIN_MASTER_GRIPER: u32 = 1965;
+static MIN_PUPPET_GRIPER: u32 = 2500;
+use clap::Parser;
+
+/// Simple aloha teleop program for recording data
+#[derive(Parser, Debug)]
+#[command(version, about, long_about = None)]
+struct Args {
+    #[arg(short, long, default_value = "/dev/ttyDXL_master_right")]
+    master_path: String,
+
+    #[arg(short, long, default_value = "/dev/ttyDXL_puppet_right")]
+    puppet_path: String,
+
+    #[arg(long, default_value = "1000000")]
+    master_baudrate: u32,
+
+    #[arg(long, default_value = "1000000")]
+    puppet_baudrate: u32,
+}
+
+enum State {
+    Position(Vec<u32>),
+    GoalPosition(Vec<u32>),
+}
+
+fn main_multithreaded(
+    io: DynamixelSerialIO,
+    mut master_serial_port: Box<dyn SerialPort>,
+    mut puppet_serial_port: Box<dyn SerialPort>,
+) -> Result<()> {
+    let (tx, rx) = mpsc::channel();
+    let (tx_dora, rx_dora) = mpsc::channel();
+    let tx_dora_read = tx_dora.clone();
+    std::thread::spawn(move || loop {
+        let now = Instant::now();
+        let pos = xm::sync_read_present_position(
+            &io,
+            master_serial_port.as_mut(),
+            &[1, 2, 3, 4, 5, 6, 7, 8, 9],
+        )
+        .expect("Read Communication error");
+        tx.send((now, pos.clone())).unwrap();
+        tx_dora_read.send(State::Position(pos)).unwrap();
+    });
+
+    let io = DynamixelSerialIO::v2();
+    let join = std::thread::spawn(move || {
+        while let Ok((_now, pos)) = rx.recv() {
+            // Compute linear interpolation for gripper as input and output range missmatch
+            let gripper = (pos[8] - MIN_MASTER_GRIPER) * (MAX_PUPPET_GRIPER - MIN_PUPPET_GRIPER)
+                / (MAX_MASTER_GRIPER - MIN_MASTER_GRIPER)
+                + MIN_PUPPET_GRIPER;
+            let mut target = pos;
+            target[8] = gripper;
+            xm::sync_write_goal_position(
+                &io,
+                puppet_serial_port.as_mut(),
+                &[1, 2, 3, 4, 5, 6, 7, 8, 9],
+                &target,
+            )
+            .expect("Write Communication error");
+            // println!("elapsed time: {:?}", now.elapsed());
+            tx_dora.send(State::GoalPosition(target)).unwrap();
+        }
+    });
+
+    if std::env::var("DORA_NODE_CONFIG").is_ok() {
+        let (mut node, mut events) = DoraNode::init_from_env()?;
+        while let Ok(target) = rx_dora.recv() {
+            let parameters = MetadataParameters::default();
+            match target {
+                State::Position(pos) => {
+                    let output = DataId::from("puppet_goal_position".to_owned());
+                    node.send_output(output.clone(), parameters, pos.into_arrow())?;
+                }
+                State::GoalPosition(pos) => {
+                    let output = DataId::from("puppet_state".to_owned());
+                    node.send_output(output.clone(), parameters, pos.into_arrow())?;
+                }
+            }
+            if events.recv_timeout(Duration::from_nanos(100)).is_none() {
+                println!("Events channel finished");
+                break;
+            }
+        }
+    } else {
+        join.join().unwrap();
+    };
+    Ok(())
+}
+
+fn main() -> Result<()> {
+    let args = Args::parse();
+    let master_serial_port = serialport::new(args.master_path, args.master_baudrate)
+        .timeout(Duration::from_millis(2))
+        .open()
+        .context("Failed to open port")?;
+    let mut puppet_serial_port = serialport::new(args.puppet_path, args.puppet_baudrate)
+        .timeout(Duration::from_millis(2))
+        .open()
+        .context("Failed to open port")?;
+    let io = DynamixelSerialIO::v2();
+    xm::sync_write_torque_enable(
+        &io,
+        puppet_serial_port.as_mut(),
+        &[1, 2, 3, 4, 5, 6, 7, 8, 9],
+        &[1; 9],
+    )
+    .expect("Communication error");
+
+    main_multithreaded(io, master_serial_port, puppet_serial_port)?;
+    Ok(())
+}

v0.0.1/compress_image.py

@@ -0,0 +1,28 @@
+from dora import Node
+import shutil
+
+FPS = 50
+
+frame_id = 0
+
+node = Node()
+
+for event in node:
+    if event["TYPE"] != "INPUT":
+        break
+
+    result = {"path": f"videos/{fname}", "timestamp": frame_id / FPS}
+
+    frame_id += 1
+
+
+tmp_imgs_dir = out_dir / "tmp_images"
+save_images_concurrently(imgs_array, tmp_imgs_dir)
+
+# encode images to a mp4 video
+fname = f"{img_key}_episode_{ep_idx:06d}.mp4"
+video_path = "out" / "videos" / fname
+encode_video_frames(tmp_imgs_dir, video_path, FPS)
+
+# clean temporary images directory
+shutil.rmtree(tmp_imgs_dir)

v0.0.1/episode_1.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fb0cb717b54bda0a3460241096e9b5e974e9da44a89722959693c5a347af69d2
+size 42285

v0.0.1/episode_2.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0350bb61ff20b4c9d4b67e1293b1c45ec82942fadbefaf51a8d29b3998cdbe66
+size 36604

v0.0.1/episode_3.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7c37d6ac89906fd6f313641ad371923c0f9044e45463deeb274b9003ad46eab5
+size 33102

v0.0.1/episode_4.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:61ce815a1d8a9907f6b0935884f25a8c1359835669e8598424f50610433884e4
+size 70380

v0.0.1/keyboard_node.py

@@ -0,0 +1,28 @@
+from pynput import keyboard
+from pynput.keyboard import Key, Events
+import pyarrow as pa
+from dora import Node
+
+
+node = Node()
+buffer_text = ""
+space = False
+submitted_text = []
+cursor = 1
+with keyboard.Events() as events:
+    while True:
+        event = events.get(0.1)
+        if event is not None and isinstance(event, Events.Press):
+            if event.key == Key.space and space == False:
+                node.send_output("space", pa.array([cursor]))
+                space = True
+
+        elif event is not None and isinstance(event, Events.Release):
+            if event.key == Key.space:
+                node.send_output("space", pa.array([0]))
+                cursor += 1
+                space = False
+
+        if node.next(0.001) is None:
+            break
+# 1

v0.0.1/lerobot_webcam_saver.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import os
+import time
+import numpy as np
+import cv2
+import pyarrow as pa
+from pathlib import Path
+from dora import Node
+import subprocess
+
+node = Node()
+
+CAMERA_NAME = os.getenv("CAMERA_NAME", "camera" )
+CAMERA_WIDTH = 640
+CAMERA_HEIGHT = 480
+FPS = 50
+
+i = 0
+episode = 0
+out_dir = "videos" / Path(f"cam_{CAMERA_NAME}_episode_{episode}")
+
+for event in node:
+    event_type = event["type"]
+    if event_type == "INPUT":
+        if event["id"] == "record_episode":
+            record_episode = event["value"].to_numpy()[0]
+            print(f"Recording episode {record_episode}", flush=True)
+            # Save Episode Video
+            if episode != 0 and record_episode == 0:
+                out_dir = "videos" / Path(f"{CAMERA_NAME}_episode_{episode}")
+                fname = f"{CAMERA_NAME}_episode_{episode}.mp4"
+                video_path = Path("videos") / fname
+                # Save video
+                ffmpeg_cmd = (
+                    f"ffmpeg -r {FPS} "
+                    "-f image2 "
+                    "-loglevel error "
+                    f"-i {str(out_dir / 'frame_%06d.png')} "
+                    "-vcodec libx264 "
+                    "-g 2 "
+                    "-pix_fmt yuv444p "
+                    f"{str(video_path)}"
+                )
+                print(ffmpeg_cmd, flush=True)
+                subprocess.Popen(ffmpeg_cmd.split(" "), start_new_session=True)
+                episode = record_episode
+                
+            # Make new directory and start saving images
+            elif episode == 0 and record_episode != 0:
+                episode = record_episode
+                out_dir = "videos" / Path(f"{CAMERA_NAME}_episode_{episode}")
+                out_dir.mkdir(parents=True, exist_ok=True)
+                i = 0
+            else:
+                continue
+                
+        elif event["id"] == "image":
+            # Only record image when in episode.
+            # Episode 0 is for not recording periods.
+            if episode == 0:
+                continue
+
+            fname = f"{CAMERA_NAME}_episode_{episode}.mp4"
+            node.send_output(
+                "saved_image",
+                pa.array([{"path": f"videos/{fname}", "timestamp": i / FPS}]),
+                event["metadata"],
+            )
+            image = event["value"].to_numpy().reshape((CAMERA_HEIGHT, CAMERA_WIDTH, 3))
+            path = str(out_dir / f"frame_{i:06d}.png")
+            cv2.imwrite(path, image)
+            i += 1

v0.0.1/llm_op.py

@@ -0,0 +1,234 @@
+from dora import DoraStatus
+import pylcs
+import os
+import pyarrow as pa
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+
+import gc  # garbage collect library
+import re
+import time
+
+CHATGPT = False
+MODEL_NAME_OR_PATH = "TheBloke/deepseek-coder-6.7B-instruct-GPTQ"
+
+CODE_MODIFIER_TEMPLATE = """
+### Instruction
+Respond with one block of modified code only in ```python block. No explaination.
+
+```python
+{code}
+```
+
+{user_message}
+
+### Response:
+"""
+
+
+model = AutoModelForCausalLM.from_pretrained(
+    MODEL_NAME_OR_PATH,
+    device_map="auto",
+    trust_remote_code=True,
+    revision="main",
+    max_length=1024,
+).to("cuda:0")
+
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME_OR_PATH, use_fast=True)
+
+
+def extract_python_code_blocks(text):
+    """
+    Extracts Python code blocks from the given text that are enclosed in triple backticks with a python language identifier.
+
+    Parameters:
+    - text: A string that may contain one or more Python code blocks.
+
+    Returns:
+    - A list of strings, where each string is a block of Python code extracted from the text.
+    """
+    pattern = r"```python\n(.*?)\n```"
+    matches = re.findall(pattern, text, re.DOTALL)
+    if len(matches) == 0:
+        pattern = r"```python\n(.*?)(?:\n```|$)"
+        matches = re.findall(pattern, text, re.DOTALL)
+        if len(matches) == 0:
+            return [text]
+        else:
+            matches = [remove_last_line(matches[0])]
+
+    return matches
+
+
+def remove_last_line(python_code):
+    """
+    Removes the last line from a given string of Python code.
+
+    Parameters:
+    - python_code: A string representing Python source code.
+
+    Returns:
+    - A string with the last line removed.
+    """
+    lines = python_code.split("\n")  # Split the string into lines
+    if lines:  # Check if there are any lines to remove
+        lines.pop()  # Remove the last line
+    return "\n".join(lines)  # Join the remaining lines back into a string
+
+
+def calculate_similarity(source, target):
+    """
+    Calculate a similarity score between the source and target strings.
+    This uses the edit distance relative to the length of the strings.
+    """
+    edit_distance = pylcs.edit_distance(source, target)
+    max_length = max(len(source), len(target))
+    # Normalize the score by the maximum possible edit distance (the length of the longer string)
+    similarity = 1 - (edit_distance / max_length)
+    return similarity
+
+
+def find_best_match_location(source_code, target_block):
+    """
+    Find the best match for the target_block within the source_code by searching line by line,
+    considering blocks of varying lengths.
+    """
+    source_lines = source_code.split("\n")
+    target_lines = target_block.split("\n")
+
+    best_similarity = 0
+    best_start_index = 0
+    best_end_index = -1
+
+    # Iterate over the source lines to find the best matching range for all lines in target_block
+    for start_index in range(len(source_lines) - len(target_lines) + 1):
+        for end_index in range(start_index + len(target_lines), len(source_lines) + 1):
+            current_window = "\n".join(source_lines[start_index:end_index])
+            current_similarity = calculate_similarity(current_window, target_block)
+            if current_similarity > best_similarity:
+                best_similarity = current_similarity
+                best_start_index = start_index
+                best_end_index = end_index
+
+    # Convert line indices back to character indices for replacement
+    char_start_index = len("\n".join(source_lines[:best_start_index])) + (
+        1 if best_start_index > 0 else 0
+    )
+    char_end_index = len("\n".join(source_lines[:best_end_index]))
+
+    return char_start_index, char_end_index
+
+
+def replace_code_in_source(source_code, replacement_block: str):
+    """
+    Replace the best matching block in the source_code with the replacement_block, considering variable block lengths.
+    """
+    replacement_block = extract_python_code_blocks(replacement_block)[0]
+    start_index, end_index = find_best_match_location(source_code, replacement_block)
+    if start_index != -1 and end_index != -1:
+        # Replace the best matching part with the replacement block
+        new_source = (
+            source_code[:start_index] + replacement_block + source_code[end_index:]
+        )
+        return new_source
+    else:
+        return source_code
+
+
+class Operator:
+    def __init__(self) -> None:
+        self.policy_init = False
+
+    def on_event(
+        self,
+        dora_event,
+        send_output,
+    ) -> DoraStatus:
+        global model, tokenizer
+        if dora_event["type"] == "INPUT" and dora_event["id"] == "text":
+            input = dora_event["value"][0].as_py()
+            # Path to the current file
+            current_file_path = __file__
+
+            # Directory of the current file
+            current_directory = os.path.dirname(current_file_path)
+            path = current_directory + "/policy.py"
+
+            with open(path, "r", encoding="utf8") as f:
+                code = f.read()
+
+            user_message = input
+            start_llm = time.time()
+
+            output = self.ask_llm(
+                CODE_MODIFIER_TEMPLATE.format(code=code, user_message=user_message)
+            )
+
+            source_code = replace_code_in_source(code, output)
+            print("response time:", time.time() - start_llm, flush=True)
+
+            print("response: ", output, flush=True)
+            with open(path, "w") as file:
+                file.write(source_code)
+
+            gc.collect()
+            torch.cuda.empty_cache()
+
+        return DoraStatus.CONTINUE
+
+    def ask_llm(self, prompt):
+
+        # Generate output
+        # prompt = PROMPT_TEMPLATE.format(system_message=system_message, prompt=prompt))
+        input = tokenizer(prompt, return_tensors="pt")
+        input_ids = input.input_ids.cuda()
+
+        # add attention mask here
+        attention_mask = input.attention_mask.cuda()
+
+        output = model.generate(
+            inputs=input_ids,
+            temperature=0.7,
+            do_sample=True,
+            top_p=0.95,
+            top_k=40,
+            max_new_tokens=512,
+            attention_mask=attention_mask,
+            eos_token_id=tokenizer.eos_token_id,
+        )
+        # Get the tokens from the output, decode them, print them
+
+        # Get text between im_start and im_end
+        return tokenizer.decode(output[0], skip_special_tokens=True)[len(prompt) :]
+
+
+if __name__ == "__main__":
+    op = Operator()
+
+    # Path to the current file
+    current_file_path = __file__
+
+    # Directory of the current file
+    current_directory = os.path.dirname(current_file_path)
+
+    path = current_directory + "/policy.py"
+    with open(path, "r", encoding="utf8") as f:
+        raw = f.read()
+
+    op.on_event(
+        {
+            "type": "INPUT",
+            "id": "text",
+            "value": pa.array(
+                [
+                    {
+                        "path": path,
+                        "user_message": "When I say suit up, get the hat and the get the food.",
+                    },
+                ]
+            ),
+            "metadata": [],
+        },
+        print,
+    )

v0.0.1/plot_node.py

@@ -0,0 +1,53 @@
+import os
+import cv2
+from dora import Node
+
+
+IMAGE_WIDTH = int(os.getenv("IMAGE_WIDTH", "1280"))
+IMAGE_HEIGHT = int(os.getenv("IMAGE_HEIGHT", "720"))
+FONT = cv2.FONT_HERSHEY_SIMPLEX
+
+
+node = Node()
+
+joint = None
+text = None
+
+for event in node:
+    if event["type"] == "INPUT":
+        dora_id = event["id"]
+
+        if dora_id == "position":
+            joint = event["value"].to_numpy()
+        if "text" in dora_id:
+            text = event["value"][0].as_py()
+
+        if dora_id == "image":
+            image = (
+                event["value"].to_numpy().reshape((IMAGE_HEIGHT, IMAGE_WIDTH, 3)).copy()
+            )
+            if text is not None:
+                cv2.putText(
+                    image,
+                    f"Speech: {text}",
+                    (20, 40),
+                    FONT,
+                    0.5,
+                    (190, 250, 0),
+                    2,
+                )
+
+            if joint is not None:
+                cv2.putText(
+                    image,
+                    f"pos: {joint}",
+                    (20, 20),
+                    FONT,
+                    0.5,
+                    (190, 250, 100),
+                    2,
+                )
+
+            cv2.imshow("frame", image)
+            if cv2.waitKey(1) & 0xFF == ord("q"):
+                break

v0.0.1/policy.py

@@ -0,0 +1,17 @@
+import pyarrow as pa
+from dora import DoraStatus
+
+
+class Operator:
+    def __init__(self):
+        self.actions = ["get_food", "get_hat"]
+
+    def on_event(self, event: dict, send_output) -> DoraStatus:
+        if event["type"] == "INPUT":
+            id = event["id"]
+            # On initialization
+            if id == "speech":
+                text: str = event["value"][0].as_py().lower()
+                # send_output("action", pa.array([""]))
+
+        return DoraStatus.CONTINUE

v0.0.1/realsense_node.py

@@ -0,0 +1,26 @@
+import pyrealsense2 as rs
+import numpy as np
+from dora import Node
+import pyarrow as pa
+import os
+import cv2
+
+IMAGE_WIDTH = int(os.getenv("IMAGE_WIDTH", "1280"))
+IMAGE_HEIGHT = int(os.getenv("IMAGE_HEIGHT", "720"))
+CAMERA_ID = os.getenv("CAMERA_ID")
+pipe = rs.pipeline()
+config = rs.config()
+config.enable_device(CAMERA_ID)
+config.enable_stream(rs.stream.color, IMAGE_WIDTH, IMAGE_HEIGHT, rs.format.bgr8, 15)
+profile = pipe.start(config)
+
+node = Node()
+
+for event in node:
+    frames = pipe.wait_for_frames()
+    color_frame = frames.get_color_frame()
+    color_images = np.asanyarray(color_frame.get_data())
+    node.send_output("image", pa.array(color_images.ravel()))
+    cv2.imshow(CAMERA_ID, color_images)
+    if cv2.waitKey(1) & 0xFF == ord("q"):
+        break

v0.0.1/record_2arms_teleop.yml

@@ -0,0 +1,125 @@
+nodes:
+  # - id: teleop_left
+    # custom:
+      # source: cargo
+      # args: run --release -p aloha-teleop  -- --master-path /dev/ttyDXL_master_left --puppet-path /dev/ttyDXL_puppet_left
+      # outputs:
+        # - puppet_goal_position
+        # - puppet_state
+  
+  - id: teleop_right
+    custom:
+      source: cargo
+      args: run --release -p aloha-teleop  -- --master-path /dev/ttyDXL_master_right --puppet-path /dev/ttyDXL_puppet_right
+      inputs:
+        heartbeat: dora/timer/millis/20
+      outputs:
+        - puppet_goal_position
+        - puppet_state
+
+  - id: dora-record
+    custom:
+      build: cargo install --git https://github.com/dora-rs/dora dora-record
+      source: dora-record
+      inputs:
+        # puppet_left_goal_position: teleop_left/puppet_goal_position
+        action: teleop_right/puppet_goal_position
+        # puppet_left_state: teleop_left/puppet_state
+        state: teleop_right/puppet_state
+        record_episode: keyboard/space
+        cam_left_wrist: cam_saver_left_wrist/saved_image
+        cam_right_wrist: cam_saver_right_wrist/saved_image
+        cam_bottom: cam_saver_bottom/saved_image
+        cam_high: cam_saver_high/saved_image
+
+  - id: cam_left_wrist
+    custom:
+      source: ../nodes/webcam.py
+      inputs:
+        tick: dora/timer/millis/20
+      outputs:
+        - image
+      envs:
+        CAMERA_INDEX: 2
+
+  - id: cam_right_wrist
+    custom:
+      source: ../nodes/webcam.py
+      inputs:
+        tick: dora/timer/millis/20
+      outputs:
+        - image
+      envs:
+        CAMERA_INDEX: 22
+  
+  - id: cam_bottom
+    custom:
+      source: ../nodes/webcam.py
+      inputs:
+        tick: dora/timer/millis/20
+      outputs:
+        - image
+      envs:
+        CAMERA_INDEX: 8
+  
+  - id: cam_high
+    custom:
+      source: ../nodes/webcam.py
+      inputs:
+        tick: dora/timer/millis/20
+      outputs:
+        - image
+      envs:
+        CAMERA_INDEX: 14
+  
+  - id: keyboard
+    custom: 
+      source: ../nodes/keyboard_node.py
+      inputs:
+        heartbeat: dora/timer/millis/20
+      outputs:
+        - space
+
+  - id: cam_saver_left_wrist
+    custom:
+      source: ../nodes/lerobot_webcam_saver.py
+      inputs:
+        image: cam_left_wrist/image
+        record_episode: keyboard/space
+      outputs:
+        - saved_image
+      envs:
+        CAMERA_NAME: cam_left_wrist
+
+  - id: cam_saver_right_wrist
+    custom:
+      source: ../nodes/lerobot_webcam_saver.py
+      inputs:
+        image: cam_right_wrist/image
+        record_episode: keyboard/space
+      outputs:
+        - saved_image
+      envs:
+        CAMERA_NAME: cam_right_wrist
+
+  - id: cam_saver_bottom
+    custom:
+      source: ../nodes/lerobot_webcam_saver.py
+      inputs:
+        image: cam_bottom/image
+        record_episode: keyboard/space
+      outputs:
+        - saved_image
+      envs:
+        CAMERA_NAME: cam_bottom
+
+  - id: cam_saver_high
+    custom:
+      source: ../nodes/lerobot_webcam_saver.py
+      inputs:
+        image: cam_up/image
+        record_episode: keyboard/space
+      outputs:
+        - saved_image
+      envs:
+        CAMERA_NAME: cam_high

v0.0.1/replay.py

@@ -0,0 +1,27 @@
+from dora import Node
+import pandas as pd
+import pyarrow as pa
+import time
+
+
+TOPIC = "puppet_goal_position"
+
+
+if __name__ == "__main__":
+    node = Node()
+
+    for event in node:
+        if event["type"] == "INPUT":
+            for action in event["value"]:
+                print(action, flush=True)
+                action = action.as_py()
+
+                df = pd.read_parquet(action + ".parquet")
+
+                initial_time = df["timestamp_utc"].iloc[0]
+                current_time = initial_time
+                for index, row in df.iterrows():
+                    delta_time = (row["timestamp_utc"] - current_time).microseconds
+                    current_time = row["timestamp_utc"]
+                    time.sleep(delta_time / 1_000_000)
+                    node.send_output(TOPIC, pa.array(row[TOPIC], type=pa.uint32()))

v0.0.1/videos/cam_bottom_episode_1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e4f0bcfd515557c5f2bab4c3ab9017259e0bee53472219707a226007194cf30
+size 3158732

v0.0.1/videos/cam_bottom_episode_2.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e10c84b3ef013fbff8e9c57ab11f0a70caf32be719aacc7c1cd5cf9968b79521
+size 2678292

v0.0.1/videos/cam_bottom_episode_3.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:be545dfb0cc4e44e3b0ff1d5332afb55dc7db71331f0a7feac289ab2802af877
+size 2198902

v0.0.1/videos/cam_bottom_episode_4.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cf203cf3af951a0750c000dcacfe5e5e9b60df0d35bc9c3a08e97ccfd42051ab
+size 6130834

v0.0.1/videos/cam_left_wrist_episode_1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fc61cb434dd1e11ce5e9a4c620d847c1d15a02119ec358731989193ce2d180f6
+size 2300015

v0.0.1/videos/cam_left_wrist_episode_2.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e804bc3ae0802ff2e6bc8664f595e39cb7f14806fde7a0e81ea7fc1d0752cb29
+size 1133727

v0.0.1/videos/cam_left_wrist_episode_4.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d4cb5314c5cf9ba0c99d44fb23d0dc7703eb153962c94666fb797f9806940199
+size 2517780

v0.0.1/videos/cam_right_wrist_episode_1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:44f7a972481d14c291425d06edb6adcd58604a3f06aa7adeb0e1d48881b04a04
+size 3803200

v0.0.1/videos/cam_right_wrist_episode_2.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6b8c56eb557a192e5ca892e156102a9f5de80b52bd0281e34dbc105a9a8666c7
+size 2467078

v0.0.1/videos/cam_right_wrist_episode_3.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:62a442a29ed41d0c94a815c79f4b89b580dd2e7c2344072f1894fe318e7a35c9
+size 2297313

v0.0.1/videos/cam_right_wrist_episode_4.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:33d95fb5203acc5a4b65896717db822c0836510998fa3f81d6fce72b491a081b
+size 4973378

v0.0.1/videos/cam_up_episode_1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5ea20f9e369f5f26380403504d1701e3b2f1fface1ce8af88b7b8e950e4985be
+size 3389350

v0.0.1/videos/cam_up_episode_2.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d2807059c207e75704445a58f70a22278f6398d6fd1b7ef2f59455cff531f57f
+size 2830621

v0.0.1/videos/cam_up_episode_3.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3b8e2672570044735cf32a28e9ad786701dca327118062002f7021290e3f32a5
+size 2379028

v0.0.1/videos/cam_up_episode_4.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bf09eaee125f7c244fdbd3a238d27e608ab5d87133186c3ab07876080460361b
+size 6435591

v0.0.1/webcam.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import os
+import time
+import numpy as np
+import cv2
+import pyarrow as pa
+
+from dora import Node
+
+node = Node()
+
+CAMERA_INDEX = int(os.getenv("CAMERA_INDEX", 0))
+CAMERA_WIDTH = 640
+CAMERA_HEIGHT = 480
+video_capture = cv2.VideoCapture(CAMERA_INDEX)
+font = cv2.FONT_HERSHEY_SIMPLEX
+
+
+for event in node:
+    event_type = event["type"]
+    if event_type == "INPUT":
+        ret, frame = video_capture.read()
+        if not ret:
+            frame = np.zeros((CAMERA_HEIGHT, CAMERA_WIDTH, 3), dtype=np.uint8)
+            cv2.putText(
+                frame,
+                "No Webcam was found at index %d" % (CAMERA_INDEX),
+                (int(30), int(30)),
+                font,
+                0.75,
+                (255, 255, 255),
+                2,
+                1,
+            )
+        node.send_output(
+            "image",
+            pa.array(frame.ravel()),
+            event["metadata"],
+        )
+        cv2.imshow(str(CAMERA_INDEX), frame)
+        if cv2.waitKey(1) & 0xFF == ord("q"):
+            break
+video_capture.release()

v0.0.1/whisper_node.py

@@ -0,0 +1,59 @@
+import pyarrow as pa
+import whisper
+from pynput import keyboard
+from pynput.keyboard import Key, Events
+from dora import Node
+
+import torch
+import numpy as np
+import pyarrow as pa
+import sounddevice as sd
+import gc  # garbage collect library
+
+model = whisper.load_model("base")
+
+SAMPLE_RATE = 16000
+
+node = Node()
+
+
+def get_text(duration) -> str:
+
+    ## Microphone
+    audio_data = sd.rec(
+        int(SAMPLE_RATE * duration),
+        samplerate=SAMPLE_RATE,
+        channels=1,
+        dtype=np.int16,
+        blocking=True,
+    )
+
+    audio = audio_data.ravel().astype(np.float32) / 32768.0
+
+    ## Speech to text
+    audio = whisper.pad_or_trim(audio)
+    return model.transcribe(audio, language="en")
+
+
+## Check for keyboard event
+with keyboard.Events() as events:
+    for dora_event in node:
+        if dora_event["type"] == "INPUT":
+            event = events.get(0.1)
+            if (
+                event is not None
+                and (event.key == Key.alt_r or event.key == Key.ctrl_r)
+                and isinstance(event, Events.Press)
+            ):
+                if event.key == Key.alt_r:
+                    result = get_text(5)
+                    node.send_output(
+                        "text_llm", pa.array([result["text"]]), dora_event["metadata"]
+                    )
+                elif event.key == Key.ctrl_r:
+                    result = get_text(3)
+                    node.send_output(
+                        "text_policy",
+                        pa.array([result["text"]]),
+                        dora_event["metadata"],
+                    )