Simplifying robomaster codebase

operators/deepseek_op.py

@@ -0,0 +1,301 @@
+from dora import DoraStatus
+import pylcs
+import textwrap
+import os
+import pyarrow as pa
+import numpy as np
+from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
+import json
+
+import re
+
+
+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]
+
+    return matches
+
+
+def extract_json_code_blocks(text):
+    """
+    Extracts json code blocks from the given text that are enclosed in triple backticks with a json language identifier.
+
+    Parameters:
+    - text: A string that may contain one or more json code blocks.
+
+    Returns:
+    - A list of strings, where each string is a block of json code extracted from the text.
+    """
+    pattern = r"```json\n(.*?)\n```"
+    matches = re.findall(pattern, text, re.DOTALL)
+    if len(matches) == 0:
+        pattern = r"```json\n(.*?)(?:\n```|$)"
+        matches = re.findall(pattern, text, re.DOTALL)
+        if len(matches) == 0:
+            return [text]
+
+    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 = -1
+    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]
+    print("replacement_block: ", replacement_block)
+    replacement_block = remove_last_line(replacement_block)
+    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
+
+
+def save_as(content, path):
+    # use at the end of replace_2 as save_as(end_result, "file_path")
+    with open(path, "w") as file:
+        file.write(content)
+
+
+class Operator:
+    def __init__(self):
+        # Load tokenizer
+        model_name_or_path = "TheBloke/deepseek-coder-6.7B-instruct-GPTQ"
+        # To use a different branch, change revision
+        # For example: revision="gptq-4bit-32g-actorder_True"
+        self.model = AutoModelForCausalLM.from_pretrained(
+            model_name_or_path,
+            device_map="auto",
+            trust_remote_code=False,
+            revision="main",
+        )
+
+        self.tokenizer = AutoTokenizer.from_pretrained(
+            model_name_or_path, use_fast=True
+        )
+
+    def on_event(
+        self,
+        dora_event,
+        send_output,
+    ) -> DoraStatus:
+        if dora_event["type"] == "INPUT":
+            input = dora_event["value"][0].as_py()
+
+            if False:
+                with open(input["path"], "r", encoding="utf8") as f:
+                    raw = f.read()
+                prompt = f"{raw} \n {input['query']}.  "
+                print("prompt: ", prompt, flush=True)
+                output = self.ask_mistral(
+                    "You're a python code expert. Respond with the small modified code only. No explaination",
+                    prompt,
+                )
+                print("output: {}".format(output))
+
+                source_code = replace_code_in_source(raw, output)
+                send_output(
+                    "output_file",
+                    pa.array(
+                        [
+                            {
+                                "raw": source_code,
+                                # "path": input["path"],
+                                # "response": output,
+                                # "prompt": prompt,
+                            }
+                        ]
+                    ),
+                    dora_event["metadata"],
+                )
+            else:
+                output = self.ask_mistral(
+                    """You're a json expert. Format your response as a json with a topic and a data field in a ```json block.  No explaination needed. No code needed.
+The schema for those json are:
+- led: Int[3] (min: 0, max: 255) # RGB values
+- blaster: Int (min: 0, max: 128)
+- control: Int[3] (min: -1, max: 1)
+- rotation: Int[2] (min: -55, max: 55)
+- message: String
+
+The response should look like this: 
+```json
+{
+    "topic": "led", 
+    "data": [255, 0, 0]
+}
+```
+""",
+                    input["query"],
+                )
+                output = extract_json_code_blocks(output)[0]
+                print("output: {}".format(output), flush=True)
+                try:
+                    output = json.loads(output)
+                    if not isinstance(output["data"], list):
+                        output["data"] = [output["data"]]
+
+                    if output["topic"] in [
+                        "led",
+                        "blaster",
+                        "control",
+                        "rotation",
+                        "text",
+                    ]:
+                        print("output", output)
+                        send_output(
+                            output["topic"],
+                            pa.array(output["data"]),
+                            dora_event["metadata"],
+                        )
+                except:
+                    print("Could not parse json")
+                # if data is not iterable, put data in a list
+
+        return DoraStatus.CONTINUE
+
+    def ask_mistral(self, system_message, prompt):
+        prompt_template = f"""
+### Instruction
+{system_message}
+
+{prompt}
+
+### Response:
+"""
+
+        # Generate output
+
+        input = self.tokenizer(prompt_template, return_tensors="pt")
+        input_ids = input.input_ids.cuda()
+
+        # add attention mask here
+        attention_mask = input["attention_mask"]
+
+        output = self.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=self.tokenizer.eos_token_id,
+        )
+        # Get the tokens from the output, decode them, print them
+
+        # Get text between im_start and im_end
+        return self.tokenizer.decode(output[0], skip_special_tokens=True)[
+            len(prompt_template) :
+        ]
+
+
+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 + "plot.py"
+    with open(path, "r", encoding="utf8") as f:
+        raw = f.read()
+
+    op.on_event(
+        {
+            "type": "INPUT",
+            "id": "tick",
+            "value": pa.array(
+                [
+                    {
+                        "raw": raw,
+                        "path": path,
+                        "query": "Send message my name is Carlito",
+                    }
+                ]
+            ),
+            "metadata": [],
+        },
+        print,
+    )

operators/file_saver_op.py

@@ -18,7 +18,7 @@ class Operator:
         dora_event,
         send_output,
     ) -> DoraStatus:
-        if dora_event["type"] == "INPUT" and dora_event["id"] == "chatgpt_output_file":
+        if dora_event["type"] == "INPUT":
             input = dora_event["value"][0].as_py()
 
             with open(input["path"], "r") as file:
@@ -41,28 +41,4 @@ class Operator:
                 ),
                 dora_event["metadata"],
             )
-        if dora_event["type"] == "INPUT" and dora_event["id"] in [
-            "revert",
-            "error",
-            "failed",
-        ]:
-            if self.last_path == "":
-                return DoraStatus.CONTINUE
-
-            with open(self.last_path, "w") as file:
-                file.write(self.last_file)
-
-            send_output(
-                "saved_file",
-                pa.array(
-                    [
-                        {
-                            "raw": self.last_file,
-                            "path": self.last_path,
-                            "origin": dora_event["id"],
-                        }
-                    ]
-                ),
-                self.last_metadata,
-            )
         return DoraStatus.CONTINUE

operators/keybinding_op.py

@@ -1,30 +0,0 @@
-import pynput
-import pyarrow as pa
-
-from dora import Node
-
-node = Node()
-
-
-def on_key_release(key):
-    try:
-        if key.char == "1":
-            print("Key 'm' pressed up")
-            node.send_output("mic_on", pa.array([]))
-        elif key.char == "2":
-            print("Key '2' pressed up")
-            node.send_output("revert", pa.array([]))
-        elif key.char == "3":
-            print("Key '3' pressed up")
-            node.send_output("failed", pa.array([]))
-        elif key.char == "4":
-            print("Key '4' pressed up")
-            node.send_output("error", pa.array([]))
-        elif key.char == "0":
-            exit()
-
-    except AttributeError:
-        pass
-
-
-pynput.keyboard.Listener(on_release=on_key_release).run()

operators/keyboard_op.py

@@ -0,0 +1,94 @@
+from pynput import keyboard
+from pynput.keyboard import Key, Events
+import pyarrow as pa
+from dora import Node
+from tkinter import Tk
+import tkinter as tk
+
+
+node = Node()
+buffer_text = ""
+ctrl = False
+submitted_text = []
+cursor = 0
+
+NODE_TOPIC = ["record", "send", "ask", "change"]
+
+with keyboard.Events() as events:
+    while True:
+        dora_event = node.next(0.01)
+        if (
+            dora_event is not None
+            and dora_event["type"] == "INPUT"
+            and dora_event["id"] == "recording"
+        ):
+            buffer_text += dora_event["value"][0].as_py()
+            node.send_output("buffer", pa.array([buffer_text]))
+            continue
+
+        event = events.get(1.0)
+        if event is not None and isinstance(event, Events.Press):
+            if hasattr(event.key, "char"):
+                cursor = 0
+                if ctrl and event.key.char == "v":
+                    r = Tk()
+                    r.update()
+                    try:
+                        selection = r.clipboard_get()
+                        r.withdraw()
+                        r.update()
+                    except tk.TclError:
+                        selection = ""
+                    r.destroy()
+                    buffer_text += selection
+                    node.send_output("buffer", pa.array([buffer_text]))
+                elif ctrl and event.key.char == "c":
+                    r = Tk()
+                    r.clipboard_clear()
+                    r.clipboard_append(buffer_text)
+                    r.update()
+                    r.destroy()
+                elif ctrl and event.key.char == "x":
+                    r = Tk()
+                    r.clipboard_clear()
+                    r.clipboard_append(buffer_text)
+                    r.update()
+                    r.destroy()
+                    buffer_text = ""
+                    node.send_output("buffer", pa.array([buffer_text]))
+                else:
+                    buffer_text += event.key.char
+                    node.send_output("buffer", pa.array([buffer_text]))
+            else:
+                if event.key == Key.backspace:
+                    buffer_text = buffer_text[:-1]
+                    node.send_output("buffer", pa.array([buffer_text]))
+                elif event.key == Key.esc:
+                    buffer_text = ""
+                    node.send_output("buffer", pa.array([buffer_text]))
+                elif event.key == Key.enter:
+                    node.send_output("submitted", pa.array([buffer_text]))
+                    first_word = buffer_text.split(" ")[0]
+                    if first_word in NODE_TOPIC:
+                        node.send_output(first_word, pa.array([buffer_text]))
+                    submitted_text.append(buffer_text)
+                    buffer_text = ""
+                    node.send_output("buffer", pa.array([buffer_text]))
+                elif event.key == Key.ctrl:
+                    ctrl = True
+                elif event.key == Key.space:
+                    buffer_text += " "
+                    node.send_output("buffer", pa.array([buffer_text]))
+                elif event.key == Key.up:
+                    if len(submitted_text) > 0:
+                        cursor = max(cursor - 1, -len(submitted_text))
+                        buffer_text = submitted_text[cursor]
+                        node.send_output("buffer", pa.array([buffer_text]))
+                elif event.key == Key.down:
+                    if len(submitted_text) > 0:
+                        cursor = min(cursor + 1, 0)
+                        buffer_text = submitted_text[cursor]
+                        node.send_output("buffer", pa.array([buffer_text]))
+        elif event is not None and isinstance(event, Events.Release):
+            if event.key == Key.ctrl:
+                ctrl = False

operators/llm_op.py

@@ -0,0 +1,340 @@
+from dora import DoraStatus
+import pylcs
+import os
+import pyarrow as pa
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import json
+
+import re
+import time
+
+MODEL_NAME_OR_PATH = "TheBloke/deepseek-coder-6.7B-instruct-GPTQ"
+# MODEL_NAME_OR_PATH = "hanspeterlyngsoeraaschoujensen/deepseek-math-7b-instruct-GPTQ"
+
+CODE_MODIFIER_TEMPLATE = """
+### Instruction
+Respond with the whole modified code only in ```python block. No explaination.
+
+```python
+{code}
+```
+
+{user_message}
+
+### Response:
+"""
+
+
+MESSAGE_SENDER_TEMPLATE = """
+### Instruction
+You're a json expert. Format your response as a json with a topic and a data field in a ```json block.  No explaination needed. No code needed.
+The schema for those json are:
+- led: Int[3] (min: 0, max: 255)
+- blaster: Int (min: 0, max: 128)
+- control: Int[3] (min: -1, max: 1)
+- rotation: Int[2] (min: -55, max: 55)
+- line: Int[4]
+
+The response should look like this: 
+```json
+
+ [
+  {{ "topic": "line", "data": [10, 10, 90, 10] }},
+]
+```
+
+{user_message}
+
+### Response:
+"""
+
+ASSISTANT_TEMPLATE = """
+### Instruction
+You're a helpuf assistant named dora. 
+Reply with a short message. No code needed. 
+
+User {user_message}
+
+### Response:
+"""
+
+
+model = AutoModelForCausalLM.from_pretrained(
+    MODEL_NAME_OR_PATH,
+    device_map="auto",
+    trust_remote_code=True,
+    revision="main",
+)
+
+
+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 extract_json_code_blocks(text):
+    """
+    Extracts json code blocks from the given text that are enclosed in triple backticks with a json language identifier.
+
+    Parameters:
+    - text: A string that may contain one or more json code blocks.
+
+    Returns:
+    - A list of strings, where each string is a block of json code extracted from the text.
+    """
+    pattern = r"```json\n(.*?)\n```"
+    matches = re.findall(pattern, text, re.DOTALL)
+    if len(matches) == 0:
+        pattern = r"```json\n(.*?)(?:\n```|$)"
+        matches = re.findall(pattern, text, re.DOTALL)
+        if len(matches) == 0:
+            return [text]
+
+    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 on_event(
+        self,
+        dora_event,
+        send_output,
+    ) -> DoraStatus:
+        if dora_event["type"] == "INPUT" and dora_event["id"] == "code_modifier":
+            input = dora_event["value"][0].as_py()
+
+            with open(input["path"], "r", encoding="utf8") as f:
+                code = f.read()
+
+            user_message = input["user_message"]
+            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)
+            send_output(
+                "modified_file",
+                pa.array(
+                    [
+                        {
+                            "raw": source_code,
+                            "path": input["path"],
+                            "response": output,
+                            "prompt": input["user_message"],
+                        }
+                    ]
+                ),
+                dora_event["metadata"],
+            )
+            print("response: ", output, flush=True)
+            send_output(
+                "assistant_message",
+                pa.array([output]),
+                dora_event["metadata"],
+            )
+        elif dora_event["type"] == "INPUT" and dora_event["id"] == "message_sender":
+            user_message = dora_event["value"][0].as_py()
+            output = self.ask_llm(
+                MESSAGE_SENDER_TEMPLATE.format(user_message=user_message)
+            )
+            outputs = extract_json_code_blocks(output)[0]
+            print("response: ", output, flush=True)
+            try:
+                outputs = json.loads(outputs)
+                if not isinstance(outputs, list):
+                    outputs = [outputs]
+                for output in outputs:
+                    if not isinstance(output["data"], list):
+                        output["data"] = [output["data"]]
+
+                    if output["topic"] in ["led", "blaster"]:
+                        send_output(
+                            output["topic"],
+                            pa.array(output["data"]),
+                            dora_event["metadata"],
+                        )
+                    else:
+                        print("Could not find the topic: {}".format(output["topic"]))
+            except:
+                print("Could not parse json")
+            # if data is not iterable, put data in a list
+        elif dora_event["type"] == "INPUT" and dora_event["id"] == "assistant":
+            user_message = dora_event["value"][0].as_py()
+            output = self.ask_llm(ASSISTANT_TEMPLATE.format(user_message=user_message))
+            send_output(
+                "assistant_message",
+                pa.array([output]),
+                dora_event["metadata"],
+            )
+        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"]
+
+        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) :]
+
+    def ask_chatgpt(self, prompt):
+        from openai import OpenAI
+
+        client = OpenAI()
+        print("---asking chatgpt: ", prompt, flush=True)
+        response = client.chat.completions.create(
+            model="gpt-4-turbo-preview",
+            messages=[
+                {"role": "system", "content": "You are a helpful assistant."},
+                {"role": "user", "content": prompt},
+            ],
+        )
+        answer = response.choices[0].message.content
+
+        print("Done", flush=True)
+        return answer
+
+
+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 + "object_detection.py"
+    with open(path, "r", encoding="utf8") as f:
+        raw = f.read()
+
+    op.on_event(
+        {
+            "type": "INPUT",
+            "id": "message_sender",
+            "value": pa.array(
+                [
+                    {
+                        "path": path,
+                        "user_message": "send a star ",
+                    },
+                ]
+            ),
+            "metadata": [],
+        },
+        print,
+    )

operators/microphone_op.py

@@ -1,8 +1,3 @@
-# Run this in the consol first :
-
-# pip install sounddevice numpy
-import time
-
 import numpy as np
 import pyarrow as pa
 import sounddevice as sd
@@ -30,11 +25,12 @@ class Operator:
                 samplerate=SAMPLE_RATE,
                 channels=1,
                 dtype=np.int16,
-                blocking=False,
+                blocking=True,
             )
-            time.sleep(MAX_DURATION)
 
             audio_data = audio_data.ravel().astype(np.float32) / 32768.0
             if len(audio_data) > 0:
                 send_output("audio", pa.array(audio_data), dora_event["metadata"])
+        elif dora_event["type"] == "INPUT":
+            print("Microphone is not recording", dora_event["value"][0].as_py())
         return DoraStatus.CONTINUE

operators/mistral_op.py

@@ -81,7 +81,7 @@ class Operator:
         if dora_event["type"] == "INPUT":
             input = dora_event["value"][0].as_py()
 
-            if not "send" in input["query"]:
+            if False:
                 with open(input["path"], "r", encoding="utf8") as f:
                     raw = f.read()
                 prompt = f"{raw[:400]} \n\n {input['query']}.  "
@@ -114,6 +114,7 @@ The schema for those json are:
 - led: Int[3] (min: 0, max: 255)
 - blaster: Int (min: 0, max: 128)
 - control: Int[3] (min: -1, max: 1)
+- rotation: Int[2] (min: -55, max: 55)
 
 
 """,
@@ -122,19 +123,19 @@ The schema for those json are:
                 print("output: {}".format(output), flush=True)
                 try:
                     output = json.loads(output)
+                    if not isinstance(output["data"], list):
+                        output["data"] = [output["data"]]
+
+                    if output["topic"] in ["led", "blaster", "control", "rotation"]:
+                        print("output", output)
+                        send_output(
+                            output["topic"],
+                            pa.array(output["data"]),
+                            dora_event["metadata"],
+                        )
                 except:
                     print("Could not parse json")
                 # if data is not iterable, put data in a list
-                if not isinstance(output["data"], list):
-                    output["data"] = [output["data"]]
-
-                if output["topic"] in ["led", "blaster", "control"]:
-                    print("output", output)
-                    send_output(
-                        output["topic"],
-                        pa.array(output["data"]),
-                        dora_event["metadata"],
-                    )
 
         return DoraStatus.CONTINUE
 
@@ -178,7 +179,7 @@ if __name__ == "__main__":
                     {
                         "raw": raw,
                         "path": path,
-                        "query": "Can you send red on topic led",
+                        "query": "le control a 1 0 0",
                     }
                 ]
             ),

operators/object_detection.py

@@ -9,40 +9,32 @@ pa.array([])
 CAMERA_WIDTH = 960
 CAMERA_HEIGHT = 540
 
+model = YOLO("yolov8n.pt")
+
 
 class Operator:
     """
-    Object Detection: Infering object from images using Deep Learning model YOLOv8.
+    Infering object from images
     """
 
-    def __init__(self):
-        self.model = YOLO("yolov8n.pt")
-
     def on_event(
         self,
         dora_event,
         send_output,
     ) -> DoraStatus:
         if dora_event["type"] == "INPUT":
-            return self.on_input(dora_event, send_output)
-        return DoraStatus.CONTINUE
+            frame = (
+                dora_event["value"].to_numpy().reshape((CAMERA_HEIGHT, CAMERA_WIDTH, 3))
+            )
+            frame = frame[:, :, ::-1]  # OpenCV image (BGR to RGB)
+            results = self.model(frame, verbose=False)  # includes NMS
+            # Process results for "ABC" only
+            boxes = np.array(results[0].boxes.xyxy.cpu())
+            conf = np.array(results[0].boxes.conf.cpu())
+            label = np.array(results[0].boxes.cls.cpu())
+            # concatenate them together
+            arrays = np.concatenate((boxes, conf[:, None], label[:, None]), axis=1)
+
+            send_output("bbox", pa.array(arrays.ravel()), dora_event["metadata"])
 
-    def on_input(
-        self,
-        dora_input,
-        send_output,
-    ) -> DoraStatus:
-        """Handle image"""
-
-        frame = dora_input["value"].to_numpy().reshape((CAMERA_HEIGHT, CAMERA_WIDTH, 3))
-        frame = frame[:, :, ::-1]  # OpenCV image (BGR to RGB)
-        results = self.model(frame, verbose=False)  # includes NMS
-        # Process results
-        boxes = np.array(results[0].boxes.xyxy.cpu())
-        conf = np.array(results[0].boxes.conf.cpu())
-        # COCO Label
-        label = np.array(results[0].boxes.cls.cpu())
-        # concatenate them together
-        arrays = np.concatenate((boxes, conf[:, None], label[:, None]), axis=1)
-        send_output("bbox", pa.array(arrays.ravel()), dora_input["metadata"])
         return DoraStatus.CONTINUE

operators/planning_op.py

@@ -3,6 +3,22 @@ import numpy as np
 import pyarrow as pa
 from dora import DoraStatus
 
+# front-back: [-1, 1]
+X = 0
+# left-right: [-1,1]
+Y = 0
+SPEED = 0.5
+Z = 0
+# pitch-axis angle in degrees(int): [-55, 55]
+PITCH = 0
+# yaw-axis angle in degrees(int): [-55, 55]
+ROTATION = 0
+# RGB LED(int) [0, 255]
+RGB = [0, 0, 0]
+BRIGHTNESS = [0]  # [0, 128]
+
+GOAL_OBJECTIVES = [X, Y, Z]
+GIMBAL_POSITION_GOAL = [PITCH, ROTATION]
 
 CAMERA_WIDTH = 960
 CAMERA_HEIGHT = 540
@@ -19,6 +35,7 @@ class Operator:
         dora_event: dict,
         send_output,
     ) -> DoraStatus:
+        global X, Y, SPEED, PITCH, ROTATION, RGB, BRIGHTNESS, GOAL_OBJECTIVES, GIMBAL_POSITION_GOAL
         if dora_event["type"] == "INPUT":
             if dora_event["id"] == "tick":
                 self.time = time.time()
@@ -26,4 +43,28 @@ class Operator:
                 bboxs = dora_event["value"].to_numpy()
                 self.bboxs = np.reshape(bboxs, (-1, 6))
 
+            elif dora_event["id"] == "position":
+                [x, y, z, gimbal_pitch, gimbal_yaw] = dora_event["value"].to_numpy()
+                self.position = [x, y, z]
+                direction = np.clip(
+                    np.array(GOAL_OBJECTIVES) - np.array(self.position), -1, 1
+                )
+
+                if any(abs(direction) > 0.1):
+                    x = direction[0]
+                    y = direction[1]
+                    z = direction[2]
+
+                    send_output(
+                        "control",
+                        pa.array([x, y, z]),
+                        dora_event["metadata"],
+                    )
+
+                send_output(
+                    "gimbal_control",
+                    pa.array([PITCH, ROTATION]),
+                    dora_event["metadata"],
+                )
+
         return DoraStatus.CONTINUE

operators/plot.py

@@ -1,118 +1,104 @@
 import os
-from typing import Callable, Optional, Union
-
 import cv2
-import numpy as np
-import pyarrow as pa
-from utils import LABELS
+
 
 from dora import DoraStatus
+from utils import LABELS
 
-pa.array([])
 
 CI = os.environ.get("CI")
+
 CAMERA_WIDTH = 960
 CAMERA_HEIGHT = 540
 
-font = cv2.FONT_HERSHEY_SIMPLEX
-
-writer = cv2.VideoWriter(
-    "output01.avi",
-    cv2.VideoWriter_fourcc(*"MJPG"),
-    30,
-    (CAMERA_WIDTH, CAMERA_HEIGHT),
-)
+FONT = cv2.FONT_HERSHEY_SIMPLEX
 
 
 class Operator:
     """
-    Plot image on window and additional context
+    Plot image and bounding box
     """
 
     def __init__(self):
-        self.image = []
         self.bboxs = []
-        self.bounding_box_messages = 0
-        self.image_messages = 0
-        self.text_whisper = ""
+        self.buffer = ""
+        self.submitted = []
+        self.lines = []
 
     def on_event(
         self,
-        dora_event: dict,
-        send_output: Callable[[str, Union[bytes, pa.UInt8Array], Optional[dict]], None],
-    ) -> DoraStatus:
+        dora_event,
+        send_output,
+    ):
         if dora_event["type"] == "INPUT":
-            return self.on_input(dora_event, send_output)
-        return DoraStatus.CONTINUE
-
-    def on_input(
-        self,
-        dora_input: dict,
-        send_output: Callable[[str, Union[bytes, pa.UInt8Array], Optional[dict]], None],
-    ) -> DoraStatus:
-        """
-        Plot image on window and additional context
-        """
-        if dora_input["id"] == "image":
-            frame = (
-                dora_input["value"]
-                .to_numpy()
-                .reshape((CAMERA_HEIGHT, CAMERA_WIDTH, 3))
-                .copy()  # copy the image because we want to modify it below
-            )
-            self.image = frame
-
-            self.image_messages += 1
-
-        elif dora_input["id"] == "text" and len(self.image) != 0:
-            self.text_whisper = dora_input["value"][0].as_py()
-        elif dora_input["id"] == "bbox" and len(self.image) != 0:
-            bboxs = dora_input["value"].to_numpy()
-            self.bboxs = np.reshape(bboxs, (-1, 6))
-
-            self.bounding_box_messages += 1
-
-        for bbox in self.bboxs:
-            [
-                min_x,
-                min_y,
-                max_x,
-                max_y,
-                confidence,
-                label,
-            ] = bbox
-            cv2.rectangle(
-                self.image,
-                (int(min_x), int(min_y)),
-                (int(max_x), int(max_y)),
-                (0, 255, 0),
-                2,
-            )
-
-            d = ((12 * 22) / (max_y - (CAMERA_HEIGHT / 2))) / 2.77 - 0.08
-            cv2.putText(
-                self.image,
-                LABELS[int(label)] + f", d={d:.2f}",
-                (int(max_x), int(max_y)),
-                font,
-                0.75,
-                (0, 255, 0),
-                2,
-                1,
-            )
-
-        if len(self.image) > 0:
-            cv2.putText(
-                self.image, self.text_whisper, (20, 35), font, 1, (250, 250, 250), 2, 1
-            )
-
-            if CI != "true":
-                writer.write(self.image)
-                cv2.imshow("frame", self.image)
-                if cv2.waitKey(1) & 0xFF == ord("q"):
-                    return DoraStatus.STOP
+            id = dora_event["id"]
+            value = dora_event["value"]
+            if id == "image":
+
+                image = (
+                    value.to_numpy().reshape((CAMERA_HEIGHT, CAMERA_WIDTH, 3)).copy()
+                )
+
+                for bbox in self.bboxs:
+                    [
+                        min_x,
+                        min_y,
+                        max_x,
+                        max_y,
+                        confidence,
+                        label,
+                    ] = bbox
+                    cv2.rectangle(
+                        image,
+                        (int(min_x), int(min_y)),
+                        (int(max_x), int(max_y)),
+                        (0, 255, 0),
+                    )
+                    cv2.putText(
+                        image,
+                        f"{LABELS[int(label)]}, {confidence:0.2f}",
+                        (int(max_x), int(max_y)),
+                        FONT,
+                        0.5,
+                        (0, 255, 0),
+                    )
+
+                cv2.putText(image, self.buffer, (20, 12 * 25), FONT, 1, (190, 250, 0))
+
+                for i, text in enumerate(self.submitted[::-1]):
+                    cv2.putText(
+                        image,
+                        text["content"],
+                        (20, 25 + (10 - i) * 25),
+                        FONT,
+                        1,
+                        (0, 255, 190),
+                    )
+
+                for line in self.lines:
+                    cv2.line(
+                        image,
+                        (int(line[0]), int(line[1])),
+                        (int(line[2]), int(line[3])),
+                        (0, 0, 255),
+                    )
+
+                if CI != "true":
+                    cv2.imshow("frame", image)
+                    if cv2.waitKey(1) & 0xFF == ord("q"):
+                        return DoraStatus.STOP
+            elif id == "bbox":
+                self.bboxs = value.to_numpy().reshape((-1, 6))
+            elif id == "keyboard_buffer":
+                self.buffer = value[0].as_py()
+            elif id == "line":
+                self.lines += [value.to_pylist()]
+            elif "message" in id:
+                self.submitted += [
+                    {
+                        "role": id,
+                        "content": value[0].as_py(),
+                    }
+                ]
 
         return DoraStatus.CONTINUE
-
-    def __del__(self):
-        cv2.destroyAllWindows()

operators/robot.py

@@ -51,7 +51,7 @@ class Operator:
                 ):
                     [x, y, z] = dora_event["value"].to_numpy()
                     self.event = self.ep_robot.chassis.move(
-                        x=x, y=y, z=z, xy_speed=0.5, z_speed=0
+                        x=x, y=y, z=z, xy_speed=0.8, z_speed=0.8
                     )
                     self.position[0] += x
                     self.position[1] += y
@@ -69,16 +69,14 @@ class Operator:
                     [
                         gimbal_pitch,
                         gimbal_yaw,
-                        gimbal_pitch_speed,
-                        gimbal_yaw_speed,
                     ] = dora_event["value"].to_numpy()
 
                     if self.gimbal_position != [gimbal_pitch, gimbal_yaw]:
                         self.event = self.ep_robot.gimbal.moveto(
                             pitch=gimbal_pitch,
                             yaw=gimbal_yaw,
-                            pitch_speed=gimbal_pitch_speed,
-                            yaw_speed=gimbal_yaw_speed,
+                            pitch_speed=20,
+                            yaw_speed=20,
                         )
                         self.gimbal_position[0] = gimbal_pitch
                         self.gimbal_position[1] = gimbal_yaw

operators/sentence_transformers_op.py

@@ -12,12 +12,13 @@ SHOULD_NOT_BE_INCLUDED = [
     "utils.py",
     "sentence_transformers_op.py",
     "chatgpt_op.py",
-    "mistral_op.py",
+    "llm_op.py",
 ]
 
 SHOULD_BE_INCLUDED = [
-    "planning_op.py",
+    "webcam.py",
     "object_detection.py",
+    "planning_op.py",
     "plot.py",
 ]
 
@@ -43,7 +44,6 @@ def get_all_functions(path):
 
 
 def search(query_embedding, corpus_embeddings, paths, raw, k=5, file_extension=None):
-    # TODO: filtering by file extension
     cos_scores = util.cos_sim(query_embedding, corpus_embeddings)[0]
     top_results = torch.topk(cos_scores, k=min(k, len(cos_scores)), sorted=True)
     out = []
@@ -83,15 +83,9 @@ class Operator:
                     self.raw,
                 )
                 [raw, path, score] = output[0:3]
-                print(
-                    (
-                        score,
-                        pa.array([{"raw": raw, "path": path, "query": values[0]}]),
-                    )
-                )
                 send_output(
                     "raw_file",
-                    pa.array([{"raw": raw, "path": path, "query": values[0]}]),
+                    pa.array([{"raw": raw, "path": path, "user_message": values[0]}]),
                     dora_event["metadata"],
                 )
             else:

operators/whisper_op.py

@@ -1,10 +1,3 @@
-# Run this in the consol first :
-
-# pip install sounddevice numpy scipy pydub keyboard
-
-# Don't forget to install whisper
-
-
 import pyarrow as pa
 import whisper
 
@@ -27,14 +20,6 @@ class Operator:
         if dora_event["type"] == "INPUT":
             audio = dora_event["value"].to_numpy()
             audio = whisper.pad_or_trim(audio)
-
-            ## make log-Mel spectrogram and move to the same device as the model
-            # mel = whisper.log_mel_spectrogram(audio).to(model.device)
-
-            ## decode the audio
-            # result = whisper.decode(model, mel, options)
             result = model.transcribe(audio, language="en")
-            text = result["text"]
-            print(text, flush=True)
-            send_output("text", pa.array([text]), dora_event["metadata"])
+            send_output("text", pa.array([result["text"]]), dora_event["metadata"])
         return DoraStatus.CONTINUE