Feat : Save exec block to file, More programming language supported in tools

2025-02-24 09:59:28 +01:00
parent 72989b0811
commit 35022765f7
9 changed files with 318 additions and 45 deletions
@@ -103,7 +103,7 @@ class Agent():

        for name, tool in self._tools.items():
            feedback = ""
-            blocks = tool.load_exec_block(answer)
+            blocks, save_path = tool.load_exec_block(answer)

            if blocks != None:
                output = tool.execute(blocks)
@@ -115,4 +115,6 @@ class Agent():
                return False, feedback
            if blocks == None:
                return True, feedback
+            if save_path != None:
+                tool.save_block(blocks, save_path)
            return True, feedback
@@ -10,6 +10,8 @@ class Interaction:
        self.is_active = True
        self.last_query = None
        self.last_answer = None
+        if tts_enabled:
+            self.speech.speak("Hello Sir, we are online and ready. What can I do for you ?")

    def is_active(self):
        return self.is_active
@@ -22,7 +24,7 @@ class Interaction:
                buffer = input(f">>> ")
            except EOFError:
                return None
-            if buffer == "exit":
+            if buffer == "exit" or buffer == "goodbye":
                return None
        return buffer

@@ -14,18 +14,20 @@ class Speech():
            "french": 'f'
        }
        self.voice_map = {
-            "english": ['af_alloy', 'af_aoede', 'af_bella', 'af_heart', 'af_jessica', 'af_kore', 'af_nicole', 'af_nova', 'af_river', 'af_sarah', 'af_sky', 'am_adam', 'am_echo', 'am_eric', 'am_fenrir', 'am_liam', 'am_michael', 'am_onyx', 'am_puck'],
+            "english": ['af_alloy', 'af_bella', 'af_kore', 'af_nicole', 'af_nova', 'af_sky', 'am_echo', 'am_michael', 'am_puck'],
            "chinese": ['zf_xiaobei', 'zf_xiaoni', 'zf_xiaoxiao', 'zf_xiaoyi', 'zm_yunjian', 'zm_yunxi', 'zm_yunxia', 'zm_yunyang'],
            "french": ['ff_siwis']
        }
        self.pipeline = KPipeline(lang_code=self.lang_map[language])
-        self.voice = self.voice_map[language][0]
+        self.voice = self.voice_map[language][4]
+        self.speed = 1.2

-    def speak(self, sentence):
+    def speak(self, sentence, voice_number = 2):
        sentence = self.clean_sentence(sentence)
+        self.voice = self.voice_map["english"][voice_number]
        generator = self.pipeline(
            sentence, voice=self.voice,
-            speed=1, split_pattern=r'\n+'
+            speed=self.speed, split_pattern=r'\n+'
        )
        for i, (gs, ps, audio) in enumerate(generator):
            audio_file = 'sample.wav'
@@ -46,4 +48,6 @@ class Speech():

 if __name__ == "__main__":
    speech = Speech()
-    speech.speak("hello would you like coffee ?")
+    for voice_idx in range (len(speech.voice_map["english"])):
+        print(f"Voice {voice_idx}")
+        speech.speak("I have indeed been uploaded, sir. We're online and ready.", voice_idx)
@@ -17,26 +17,37 @@ class BashInterpreter(Tools):
        super().__init__()
        self.tag = "bash"

-    def execute(self, commands: str, safety = False, timeout = 1000):
+    def execute(self, commands: str, safety=False, timeout=1000):
        """
-        Execute bash commands.
+        Execute bash commands and display output in real-time.
        """
        if safety and input("Execute command? y/n ") != "y":
            return "Command rejected by user."
-
+    
+        concat_output = ""
        for command in commands:
            try:
-                output = subprocess.check_output(command,
-                                                 shell=True,
-                                                 stderr=subprocess.STDOUT,
-                                                 universal_newlines=True,
-                                                 timeout=timeout
-                                                )
-                return output.strip()
-            except subprocess.CalledProcessError as e:
-                return f"Command execution failed:\n{e.output}"
-            except subprocess.TimeoutExpired as e:
-                return f"Command timed out. Output:\n{e.output}"
+                process = subprocess.Popen(
+                    command,
+                    shell=True,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.STDOUT,
+                    universal_newlines=True
+                )
+                command_output = ""
+                for line in process.stdout:
+                    print(line, end="")
+                    command_output += line
+                return_code = process.wait(timeout=timeout)
+                if return_code != 0:
+                    return f"Command {command} failed with return code {return_code}:\n{command_output}"
+                concat_output += f"Output of {command}:\n{command_output.strip()}\n\n"
+            except subprocess.TimeoutExpired:
+                process.kill()  # Kill the process if it times out
+                return f"Command {command} timed out. Output:\n{command_output}"
+            except Exception as e:
+                return f"Command {command} failed:\n{str(e)}"
+        return concat_output

    def interpreter_feedback(self, output):
        """
@@ -86,4 +97,4 @@ class BashInterpreter(Tools):

 if __name__ == "__main__":
    bash = BashInterpreter()
-    print(bash.execute(["ls", "pwd"]))
+    print(bash.execute(["ls", "pwd", "ip a", "nmap -sC 127.0.0.1"]))
@@ -0,0 +1,118 @@
+import subprocess
+import os
+import tempfile
+import re
+
+if __name__ == "__main__":
+    from tools import Tools
+else:
+    from sources.tools.tools import Tools
+
+class CInterpreter(Tools):
+    """
+    This class is a tool to allow agent for C code execution
+    """
+    def __init__(self):
+        super().__init__()
+        self.tag = "c"
+
+    def execute(self, codes: str, safety=False) -> str:
+        """
+        Execute C code by compiling and running it.
+        """
+        output = ""
+        code = '\n'.join(codes) if isinstance(codes, list) else codes
+        
+        if safety and input("Execute code? y/n ") != "y":
+            return "Code rejected by user."
+
+        exec_extension = ".exe" if os.name == "nt" else ""  # Windows uses .exe, Linux/Unix does not
+        
+        with tempfile.TemporaryDirectory() as tmpdirname:
+            source_file = os.path.join(tmpdirname, "temp.c")
+            exec_file = os.path.join(tmpdirname, "temp") + exec_extension
+            with open(source_file, 'w') as f:
+                f.write(code)
+
+            try:
+                compile_command = ["gcc", source_file, "-o", exec_file]
+                compile_result = subprocess.run(
+                    compile_command,
+                    capture_output=True,
+                    text=True,
+                    timeout=10
+                )
+
+                if compile_result.returncode != 0:
+                    return f"Compilation failed: {compile_result.stderr}"
+
+                run_command = [exec_file]
+                run_result = subprocess.run(
+                    run_command,
+                    capture_output=True,
+                    text=True,
+                    timeout=10
+                )
+
+                if run_result.returncode != 0:
+                    return f"Execution failed: {run_result.stderr}"
+                output = run_result.stdout
+
+            except subprocess.TimeoutExpired as e:
+                return f"Execution timed out: {str(e)}"
+            except FileNotFoundError:
+                return "Error: 'gcc' not found. Ensure a C compiler (e.g., gcc) is installed and in PATH."
+            except Exception as e:
+                return f"Code execution failed: {str(e)}"
+
+        return output
+
+    def interpreter_feedback(self, output: str) -> str:
+        """
+        Provide feedback based on the output of the code execution
+        """
+        if self.execution_failure_check(output):
+            feedback = f"[failure] Error in execution:\n{output}"
+        else:
+            feedback = "[success] Execution success, code output:\n" + output
+        return feedback
+
+    def execution_failure_check(self, feedback: str) -> bool:
+        """
+        Check if the code execution failed.
+        """
+        error_patterns = [
+            r"error", 
+            r"failed", 
+            r"traceback", 
+            r"invalid", 
+            r"exception", 
+            r"syntax", 
+            r"segmentation fault", 
+            r"core dumped", 
+            r"undefined", 
+            r"cannot"
+        ]
+        combined_pattern = "|".join(error_patterns)
+        if re.search(combined_pattern, feedback, re.IGNORECASE):
+            return True
+        return False
+
+if __name__ == "__main__":
+    codes = [
+"""
+#include <stdio.h>
+#include <stdlib.h>
+
+void hello() {
+    printf("Hello, World!\\n");
+}
+""",
+"""
+int main() {
+    hello();
+    return 0;
+}
+    """]
+    c = CInterpreter()
+    print(c.execute(codes))
@@ -0,0 +1,115 @@
+import subprocess
+import os
+import tempfile
+import re
+
+if __name__ == "__main__":
+    from tools import Tools
+else:
+    from sources.tools.tools import Tools
+
+class GoInterpreter(Tools):
+    """
+    This class is a tool to allow execution of Go code.
+    """
+    def __init__(self):
+        super().__init__()
+        self.tag = "go"
+
+    def execute(self, codes: str, safety=False) -> str:
+        """
+        Execute Go code by compiling and running it.
+        """
+        output = ""
+        code = '\n'.join(codes) if isinstance(codes, list) else codes
+
+        if safety and input("Execute code? y/n ") != "y":
+            return "Code rejected by user."
+
+        with tempfile.TemporaryDirectory() as tmpdirname:
+            source_file = os.path.join(tmpdirname, "temp.go")
+            exec_file = os.path.join(tmpdirname, "temp")
+            with open(source_file, 'w') as f:
+                f.write(code)
+
+            try:
+                compile_command = ["go", "build", "-o", exec_file, source_file]
+                compile_result = subprocess.run(
+                    compile_command,
+                    capture_output=True,
+                    text=True,
+                    timeout=10
+                )
+
+                if compile_result.returncode != 0:
+                    return f"Compilation failed: {compile_result.stderr}"
+
+                run_command = [exec_file]
+                run_result = subprocess.run(
+                    run_command,
+                    capture_output=True,
+                    text=True,
+                    timeout=10
+                )
+
+                if run_result.returncode != 0:
+                    return f"Execution failed: {run_result.stderr}"
+                output = run_result.stdout
+
+            except subprocess.TimeoutExpired as e:
+                return f"Execution timed out: {str(e)}"
+            except FileNotFoundError:
+                return "Error: 'go' not found. Ensure Go is installed and in PATH."
+            except Exception as e:
+                return f"Code execution failed: {str(e)}"
+
+        return output
+
+    def interpreter_feedback(self, output: str) -> str:
+        """
+        Provide feedback based on the output of the code execution
+        """
+        if self.execution_failure_check(output):
+            feedback = f"[failure] Error in execution:\n{output}"
+        else:
+            feedback = "[success] Execution success, code output:\n" + output
+        return feedback
+
+    def execution_failure_check(self, feedback: str) -> bool:
+        """
+        Check if the code execution failed.
+        """
+        error_patterns = [
+            r"error",
+            r"failed",
+            r"traceback",
+            r"invalid",
+            r"exception",
+            r"syntax",
+            r"panic",
+            r"undefined",
+            r"cannot"
+        ]
+        combined_pattern = "|".join(error_patterns)
+        if re.search(combined_pattern, feedback, re.IGNORECASE):
+            return True
+        return False
+
+if __name__ == "__main__":
+    codes = [
+"""
+package main
+import "fmt"
+
+func hello() {
+    fmt.Println("Hello, World!")
+}
+""",
+"""
+func main() {
+    hello()
+}
+"""
+    ]
+    g = GoInterpreter()
+    print(g.execute(codes))
@@ -71,10 +71,19 @@ class PyInterpreter(Tools):
        return False

 if __name__ == "__main__":
-    codes = ["""
-def test():
-    print("Hello world")
-test()
-    """]
+    text = """
+Sure here is how to print in python:
+```python:tmp.py
+
+def print_hello():
+    hello = "Hello World"
+    print(hello)
+
+print_hello()
+
+```
+"""
    py = PyInterpreter()
+    codes, save_path = py.load_exec_block(text)
+    py.save_block(codes, save_path)
    print(py.execute(codes))
@@ -69,8 +69,18 @@ class Tools():
        if start_idx == -1 or end_idx == -1:
            return text
        return text[:start_idx] + text[end_idx:]
+    
+    def save_block(self, blocks:[str], save_path:str) -> None:
+        """
+        Save the code/query block to a file.
+        """
+        if save_path is None:
+            return
+        for block in blocks:
+            with open(save_path, 'w') as f:
+                f.write(block)

-    def load_exec_block(self, generation: str) -> str:
+    def load_exec_block(self, llm_text: str) -> str:
        """
        Extract the code/query blocks from the answer text, removing consistent leading whitespace.
        """
@@ -79,24 +89,25 @@ class Tools():
        end_tag = '```'
        code_blocks = []
        start_index = 0
+        save_path = None

-        if start_tag not in generation:
+        if start_tag not in llm_text:
            return None

        while True:
-            start_pos = generation.find(start_tag, start_index)
+            start_pos = llm_text.find(start_tag, start_index)
            if start_pos == -1:
                break

-            line_start = generation.rfind('\n', 0, start_pos) + 1
+            line_start = llm_text.rfind('\n', 0, start_pos) + 1
            if line_start == 0:
                line_start = 0
-            leading_whitespace = generation[line_start:start_pos]
+            leading_whitespace = llm_text[line_start:start_pos]

-            end_pos = generation.find(end_tag, start_pos + len(start_tag))
+            end_pos = llm_text.find(end_tag, start_pos + len(start_tag))
            if end_pos == -1:
                break
-            content = generation[start_pos + len(start_tag):end_pos]
+            content = llm_text[start_pos + len(start_tag):end_pos]
            lines = content.split('\n')
            if leading_whitespace:
                processed_lines = []
@@ -107,7 +118,9 @@ class Tools():
                        processed_lines.append(line)
                content = '\n'.join(processed_lines)

+            if ':' in content.split('\n')[0]:
+                save_path = content.split('\n')[0].split(':')[1]
+                content = content[content.find('\n')+1:]
            code_blocks.append(content)
            start_index = end_pos + len(end_tag)
-
-        return code_blocks
+        return code_blocks, save_path