Merge branch 'main' into split-cli-jobs

Author: phil-opp

.github/workflows/ci.yml

@@ -465,10 +465,27 @@ jobs:
           fi
 
           echo "Running CI Operator Test"
+          dora build examples/python-operator-dataflow/dataflow.yml --uv
           dora start examples/python-operator-dataflow/dataflow.yml --name ci-python-operator --detach --uv
           sleep 10
           echo "Running dora stop"
           dora stop --name ci-python-operator  --grace-duration 30s
+
+      - name: "Test CLI (Python): Object Detection with external deps"
+        timeout-minutes: 30
+        # fail-fast by using bash shell explicitly
+        shell: bash
+        run: |
+          if [ "$RUNNER_OS" != "Windows" ]; then
+            source .venv/bin/activate
+          else
+            source .venv/Scripts/activate
+          fi
+          echo "Running Python object detection example with external deps"
+          dora build examples/python-dataflow/dataflow-object-detection.yml --uv
+          dora start examples/python-dataflow/dataflow-object-detection.yml --name ci-python-obj-det --detach --uv
+          sleep 10
+          dora stop --name ci-python-obj-det  --grace-duration 30s
       - name: "Test CLI (Python): Dora destroy"
         timeout-minutes: 5
         # fail-fast by using bash shell explicitly

.github/workflows/claude-code.yml

@@ -0,0 +1,37 @@
+name: Claude Code
+
+on:
+  issue_comment:
+    types: [created]
+  pull_request_review_comment:
+    types: [created]
+  issues:
+    types: [opened, assigned]
+  pull_request_review:
+    types: [submitted]
+
+jobs:
+  claude:
+    if: |
+      (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
+      (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+      issues: write
+      id-token: write
+      actions: read
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Run Claude Code
+        id: claude
+        uses: anthropics/claude-code-action@v1
+        with:
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}

examples/python-multiple-arrays/README.md

@@ -0,0 +1,30 @@
+# Fast Multi-Array Messaging with Dora
+
+Hi there! This example shows you how to send multiple numpy arrays (like several sensor readings or images) in a single Dora message with lightning-fast performance.
+
+## Why this matters
+You might have noticed that using `numpy_array.tolist()` to package data is... well, pretty slow. That's because it converts every single pixel or number into a Python object, which is heavy work for the CPU.
+
+## The Secret Sauce
+The trick is to keep things in binary format! We use `numpy_array.ravel()` to flatten the arrays efficiently and pass them straight to `pyarrow`. This lets us achieve near zero-copy performance.
+
+On the receiving end, we simply convert back to numpy and reshape. Easy peasy!
+
+## Give it a spin
+
+1.  **Get Set Up**: Make sure you have `dora` installed and the binary in your PATH.
+2.  **Install the goods**:
+    ```bash
+    pip install numpy pyarrow
+    ```
+3.  **Run it**:
+    ```bash
+    dora up
+    dora start dataflow.yml
+    ```
+
+You should see something awesome like this in your terminal:
+```
+Sent message with 3 arrays. Encoding time: 0.000345s
+Received and decoded. Shape1: (480, 640, 3), Shape2: (480, 640, 3), State: (1, 6). Time: 0.000210s
+```

examples/python-multiple-arrays/dataflow.yml

@@ -0,0 +1,12 @@
+nodes:
+  - id: sender
+    path: sender.py
+    outputs:
+      - multi_array_msg
+    inputs:
+      tick: dora/timer/millis/1000
+
+  - id: receiver
+    path: receiver.py
+    inputs:
+      multi_array_msg: sender/multi_array_msg

examples/python-multiple-arrays/receiver.py

@@ -0,0 +1,42 @@
+import numpy as np
+from dora import Node
+import time
+
+def main():
+    node = Node()
+
+    for event in node:
+        if event["type"] == "INPUT":
+            if event["id"] == "multi_array_msg":
+                t0 = time.time()
+                
+                # The event value is our PyArrow StructArray.
+                packed_data = event["value"]
+
+                # We can access the columns by name.
+                # packed_data.field('image1') gives us the column for image1.
+                
+                # Grab the arrow arrays for each field.
+                col_image1 = packed_data.field('image1')
+                col_image2 = packed_data.field('image2')
+                col_state = packed_data.field('state')
+                
+                # Now we extract the values and convert back to numpy.
+                # We take the first element since we know we sent a single batch.
+                
+                arr_image1_flat = col_image1[0].values.to_numpy(zero_copy_only=False)
+                # Reshape it back to the original image dimensions.
+                # (Ideally, you'd pass metadata for dynamic shapes, but we'll keep it simple here).
+                image1 = arr_image1_flat.view(np.uint8).reshape((480, 640, 3))
+                
+                arr_image2_flat = col_image2[0].values.to_numpy(zero_copy_only=False)
+                image2 = arr_image2_flat.view(np.uint8).reshape((480, 640, 3))
+                
+                arr_state_flat = col_state[0].values.to_numpy(zero_copy_only=False)
+                state = arr_state_flat.view(np.float32).reshape((1, 6))
+                
+                proc_time = time.time() - t0
+                print(f"Received and decoded. Shape1: {image1.shape}, Shape2: {image2.shape}, State: {state.shape}. Time: {proc_time:.6f}s", flush=True)
+
+if __name__ == "__main__":
+    main()

examples/python-multiple-arrays/sender.py

@@ -0,0 +1,41 @@
+import numpy as np
+import pyarrow as pa
+from dora import Node
+import time
+
+def main():
+    node = Node()
+    
+    # Initialize some dummy data
+    # Let's create some dummy data to send.
+    # We have two images and a state vector, just like in your robotics setup.
+    image1 = np.zeros((480, 640, 3), dtype=np.uint8)
+    image2 = np.ones((480, 640, 3), dtype=np.uint8) * 255
+    state = np.array([[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]], dtype=np.float32)
+
+    for event in node:
+        if event["type"] == "INPUT":
+            if event["id"] == "tick":
+                # Efficiently package the arrays using PyArrow.
+                # We flatten the arrays with .ravel() which is super fast and avoids expensive logic.
+                # Then we wrap them in a list of length 1 to create the arrow columns.
+                
+                t0 = time.time()
+                
+                # Fast path!
+                encoded_image1 = pa.array([image1.ravel()])
+                encoded_image2 = pa.array([image2.ravel()])
+                encoded_state = pa.array([state.ravel()])
+                
+                struct_data = pa.StructArray.from_arrays(
+                    [encoded_image1, encoded_image2, encoded_state],
+                    names=['image1', 'image2', 'state']
+                )
+                
+                node.send_output("multi_array_msg", struct_data)
+                
+                proc_time = time.time() - t0
+                print(f"Sent message with 3 arrays. Encoding time: {proc_time:.6f}s", flush=True)
+
+if __name__ == "__main__":
+    main()