janito 1.10.0__py3-none-any.whl → 1.11.1__py3-none-any.whl

janito/agent/tools/python_command_runner.py

@@ -1,4 +1,5 @@
 import subprocess
+import os
 import sys
 import tempfile
 import threading
@@ -49,102 +50,100 @@ class PythonCommandRunnerTool(ToolBase):
                     bufsize=1,
                     universal_newlines=True,
                     encoding="utf-8",
-                    env={**dict(), **dict(PYTHONIOENCODING="utf-8")},
+                    env={**os.environ, "PYTHONIOENCODING": "utf-8"},
                 )
-                stdout_lines = 0
-                stderr_lines = 0
-
-                def stream_output(stream, file_obj, report_func, count_func):
-                    nonlocal stdout_lines, stderr_lines
-                    for line in stream:
-                        file_obj.write(line)
-                        file_obj.flush()
-                        report_func(line)
-                        if count_func == "stdout":
-                            stdout_lines += 1
-                        else:
-                            stderr_lines += 1
-
-                stdout_thread = threading.Thread(
-                    target=stream_output,
-                    args=(process.stdout, stdout_file, self.report_stdout, "stdout"),
+                stdout_lines, stderr_lines = self._stream_process_output(
+                    process, stdout_file, stderr_file
                 )
-                stderr_thread = threading.Thread(
-                    target=stream_output,
-                    args=(process.stderr, stderr_file, self.report_stderr, "stderr"),
-                )
-                stdout_thread.start()
-                stderr_thread.start()
-                try:
-                    return_code = process.wait(timeout=timeout)
-                except subprocess.TimeoutExpired:
-                    process.kill()
-                    self.report_error(
-                        tr("\u274c Timed out after {timeout} seconds.", timeout=timeout)
-                    )
+                return_code = self._wait_for_process(process, timeout)
+                if return_code is None:
                     return tr(
                         "Code timed out after {timeout} seconds.", timeout=timeout
                     )
-                stdout_thread.join()
-                stderr_thread.join()
                 stdout_file.flush()
                 stderr_file.flush()
-
                 self.report_success(
                     tr("\u2705 Return code {return_code}", return_code=return_code)
                 )
-                # Read back the content for summary if not too large
-                with open(
-                    stdout_file.name, "r", encoding="utf-8", errors="replace"
-                ) as out_f:
-                    stdout_content = out_f.read()
-                with open(
-                    stderr_file.name, "r", encoding="utf-8", errors="replace"
-                ) as err_f:
-                    stderr_content = err_f.read()
-                max_lines = 100
-                stdout_lines = stdout_content.count("\n")
-                stderr_lines = stderr_content.count("\n")
-
-                def head_tail(text, n=10):
-                    lines = text.splitlines()
-                    if len(lines) <= 2 * n:
-                        return "\n".join(lines)
-                    return "\n".join(
-                        lines[:n]
-                        + ["... ({} lines omitted) ...".format(len(lines) - 2 * n)]
-                        + lines[-n:]
-                    )
-
-                if stdout_lines <= max_lines and stderr_lines <= max_lines:
-                    result = (
-                        f"Return code: {return_code}\n--- STDOUT ---\n{stdout_content}"
-                    )
-                    if stderr_content.strip():
-                        result += f"\n--- STDERR ---\n{stderr_content}"
-                    return result
-                else:
-                    result = (
-                        f"stdout_file: {stdout_file.name} (lines: {stdout_lines})\n"
-                    )
-                    if stderr_lines > 0 and stderr_content.strip():
-                        result += (
-                            f"stderr_file: {stderr_file.name} (lines: {stderr_lines})\n"
-                        )
-                    result += f"returncode: {return_code}\n"
-                    result += (
-                        "--- STDOUT (head/tail) ---\n"
-                        + head_tail(stdout_content)
-                        + "\n"
-                    )
-                    if stderr_content.strip():
-                        result += (
-                            "--- STDERR (head/tail) ---\n"
-                            + head_tail(stderr_content)
-                            + "\n"
-                        )
-                    result += "Use the get_lines tool to inspect the contents of these files when needed."
-                    return result
+                return self._format_result(
+                    stdout_file.name, stderr_file.name, return_code
+                )
         except Exception as e:
             self.report_error(tr("\u274c Error: {error}", error=e))
             return tr("Error running code: {error}", error=e)
+
+    def _stream_process_output(self, process, stdout_file, stderr_file):
+        stdout_lines = 0
+        stderr_lines = 0
+
+        def stream_output(stream, file_obj, report_func, count_func):
+            nonlocal stdout_lines, stderr_lines
+            for line in stream:
+                file_obj.write(line)
+                file_obj.flush()
+                report_func(line)
+                if count_func == "stdout":
+                    stdout_lines += 1
+                else:
+                    stderr_lines += 1
+
+        stdout_thread = threading.Thread(
+            target=stream_output,
+            args=(process.stdout, stdout_file, self.report_stdout, "stdout"),
+        )
+        stderr_thread = threading.Thread(
+            target=stream_output,
+            args=(process.stderr, stderr_file, self.report_stderr, "stderr"),
+        )
+        stdout_thread.start()
+        stderr_thread.start()
+        stdout_thread.join()
+        stderr_thread.join()
+        return stdout_lines, stderr_lines
+
+    def _wait_for_process(self, process, timeout):
+        try:
+            return process.wait(timeout=timeout)
+        except subprocess.TimeoutExpired:
+            process.kill()
+            self.report_error(
+                tr("\u274c Timed out after {timeout} seconds.", timeout=timeout)
+            )
+            return None
+
+    def _format_result(self, stdout_file_name, stderr_file_name, return_code):
+        with open(stdout_file_name, "r", encoding="utf-8", errors="replace") as out_f:
+            stdout_content = out_f.read()
+        with open(stderr_file_name, "r", encoding="utf-8", errors="replace") as err_f:
+            stderr_content = err_f.read()
+        max_lines = 100
+        stdout_lines = stdout_content.count("\n")
+        stderr_lines = stderr_content.count("\n")
+
+        def head_tail(text, n=10):
+            lines = text.splitlines()
+            if len(lines) <= 2 * n:
+                return "\n".join(lines)
+            return "\n".join(
+                lines[:n]
+                + ["... ({} lines omitted) ...".format(len(lines) - 2 * n)]
+                + lines[-n:]
+            )
+
+        if stdout_lines <= max_lines and stderr_lines <= max_lines:
+            result = f"Return code: {return_code}\n--- STDOUT ---\n{stdout_content}"
+            if stderr_content.strip():
+                result += f"\n--- STDERR ---\n{stderr_content}"
+            return result
+        else:
+            result = f"stdout_file: {stdout_file_name} (lines: {stdout_lines})\n"
+            if stderr_lines > 0 and stderr_content.strip():
+                result += f"stderr_file: {stderr_file_name} (lines: {stderr_lines})\n"
+            result += f"returncode: {return_code}\n"
+            result += "--- STDOUT (head/tail) ---\n" + head_tail(stdout_content) + "\n"
+            if stderr_content.strip():
+                result += (
+                    "--- STDERR (head/tail) ---\n" + head_tail(stderr_content) + "\n"
+                )
+            result += "Use the get_lines tool to inspect the contents of these files when needed."
+            return result

janito/agent/tools/python_file_runner.py

@@ -1,4 +1,5 @@
 import subprocess
+import os
 import sys
 import tempfile
 import threading
@@ -47,102 +48,100 @@ class PythonFileRunnerTool(ToolBase):
                     bufsize=1,
                     universal_newlines=True,
                     encoding="utf-8",
-                    env={**dict(), **dict(PYTHONIOENCODING="utf-8")},
+                    env={**os.environ, "PYTHONIOENCODING": "utf-8"},
                 )
-                stdout_lines = 0
-                stderr_lines = 0
-
-                def stream_output(stream, file_obj, report_func, count_func):
-                    nonlocal stdout_lines, stderr_lines
-                    for line in stream:
-                        file_obj.write(line)
-                        file_obj.flush()
-                        report_func(line)
-                        if count_func == "stdout":
-                            stdout_lines += 1
-                        else:
-                            stderr_lines += 1
-
-                stdout_thread = threading.Thread(
-                    target=stream_output,
-                    args=(process.stdout, stdout_file, self.report_stdout, "stdout"),
+                stdout_lines, stderr_lines = self._stream_process_output(
+                    process, stdout_file, stderr_file
                 )
-                stderr_thread = threading.Thread(
-                    target=stream_output,
-                    args=(process.stderr, stderr_file, self.report_stderr, "stderr"),
-                )
-                stdout_thread.start()
-                stderr_thread.start()
-                try:
-                    return_code = process.wait(timeout=timeout)
-                except subprocess.TimeoutExpired:
-                    process.kill()
-                    self.report_error(
-                        tr("\u274c Timed out after {timeout} seconds.", timeout=timeout)
-                    )
+                return_code = self._wait_for_process(process, timeout)
+                if return_code is None:
                     return tr(
                         "Code timed out after {timeout} seconds.", timeout=timeout
                     )
-                stdout_thread.join()
-                stderr_thread.join()
                 stdout_file.flush()
                 stderr_file.flush()
-
                 self.report_success(
                     tr("\u2705 Return code {return_code}", return_code=return_code)
                 )
-                # Read back the content for summary if not too large
-                with open(
-                    stdout_file.name, "r", encoding="utf-8", errors="replace"
-                ) as out_f:
-                    stdout_content = out_f.read()
-                with open(
-                    stderr_file.name, "r", encoding="utf-8", errors="replace"
-                ) as err_f:
-                    stderr_content = err_f.read()
-                max_lines = 100
-                stdout_lines = stdout_content.count("\n")
-                stderr_lines = stderr_content.count("\n")
-
-                def head_tail(text, n=10):
-                    lines = text.splitlines()
-                    if len(lines) <= 2 * n:
-                        return "\n".join(lines)
-                    return "\n".join(
-                        lines[:n]
-                        + ["... ({} lines omitted) ...".format(len(lines) - 2 * n)]
-                        + lines[-n:]
-                    )
-
-                if stdout_lines <= max_lines and stderr_lines <= max_lines:
-                    result = (
-                        f"Return code: {return_code}\n--- STDOUT ---\n{stdout_content}"
-                    )
-                    if stderr_content.strip():
-                        result += f"\n--- STDERR ---\n{stderr_content}"
-                    return result
-                else:
-                    result = (
-                        f"stdout_file: {stdout_file.name} (lines: {stdout_lines})\n"
-                    )
-                    if stderr_lines > 0 and stderr_content.strip():
-                        result += (
-                            f"stderr_file: {stderr_file.name} (lines: {stderr_lines})\n"
-                        )
-                    result += f"returncode: {return_code}\n"
-                    result += (
-                        "--- STDOUT (head/tail) ---\n"
-                        + head_tail(stdout_content)
-                        + "\n"
-                    )
-                    if stderr_content.strip():
-                        result += (
-                            "--- STDERR (head/tail) ---\n"
-                            + head_tail(stderr_content)
-                            + "\n"
-                        )
-                    result += "Use the get_lines tool to inspect the contents of these files when needed."
-                    return result
+                return self._format_result(
+                    stdout_file.name, stderr_file.name, return_code
+                )
         except Exception as e:
             self.report_error(tr("\u274c Error: {error}", error=e))
             return tr("Error running file: {error}", error=e)
+
+    def _stream_process_output(self, process, stdout_file, stderr_file):
+        stdout_lines = 0
+        stderr_lines = 0
+
+        def stream_output(stream, file_obj, report_func, count_func):
+            nonlocal stdout_lines, stderr_lines
+            for line in stream:
+                file_obj.write(line)
+                file_obj.flush()
+                report_func(line)
+                if count_func == "stdout":
+                    stdout_lines += 1
+                else:
+                    stderr_lines += 1
+
+        stdout_thread = threading.Thread(
+            target=stream_output,
+            args=(process.stdout, stdout_file, self.report_stdout, "stdout"),
+        )
+        stderr_thread = threading.Thread(
+            target=stream_output,
+            args=(process.stderr, stderr_file, self.report_stderr, "stderr"),
+        )
+        stdout_thread.start()
+        stderr_thread.start()
+        stdout_thread.join()
+        stderr_thread.join()
+        return stdout_lines, stderr_lines
+
+    def _wait_for_process(self, process, timeout):
+        try:
+            return process.wait(timeout=timeout)
+        except subprocess.TimeoutExpired:
+            process.kill()
+            self.report_error(
+                tr("\u274c Timed out after {timeout} seconds.", timeout=timeout)
+            )
+            return None
+
+    def _format_result(self, stdout_file_name, stderr_file_name, return_code):
+        with open(stdout_file_name, "r", encoding="utf-8", errors="replace") as out_f:
+            stdout_content = out_f.read()
+        with open(stderr_file_name, "r", encoding="utf-8", errors="replace") as err_f:
+            stderr_content = err_f.read()
+        max_lines = 100
+        stdout_lines = stdout_content.count("\n")
+        stderr_lines = stderr_content.count("\n")
+
+        def head_tail(text, n=10):
+            lines = text.splitlines()
+            if len(lines) <= 2 * n:
+                return "\n".join(lines)
+            return "\n".join(
+                lines[:n]
+                + ["... ({} lines omitted) ...".format(len(lines) - 2 * n)]
+                + lines[-n:]
+            )
+
+        if stdout_lines <= max_lines and stderr_lines <= max_lines:
+            result = f"Return code: {return_code}\n--- STDOUT ---\n{stdout_content}"
+            if stderr_content.strip():
+                result += f"\n--- STDERR ---\n{stderr_content}"
+            return result
+        else:
+            result = f"stdout_file: {stdout_file_name} (lines: {stdout_lines})\n"
+            if stderr_lines > 0 and stderr_content.strip():
+                result += f"stderr_file: {stderr_file_name} (lines: {stderr_lines})\n"
+            result += f"returncode: {return_code}\n"
+            result += "--- STDOUT (head/tail) ---\n" + head_tail(stdout_content) + "\n"
+            if stderr_content.strip():
+                result += (
+                    "--- STDERR (head/tail) ---\n" + head_tail(stderr_content) + "\n"
+                )
+            result += "Use the get_lines tool to inspect the contents of these files when needed."
+            return result

janito/agent/tools/python_stdin_runner.py

@@ -1,4 +1,5 @@
 import subprocess
+import os
 import sys
 import tempfile
 import threading
@@ -51,104 +52,102 @@ class PythonStdinRunnerTool(ToolBase):
                     bufsize=1,
                     universal_newlines=True,
                     encoding="utf-8",
-                    env={**dict(), **dict(PYTHONIOENCODING="utf-8")},
+                    env={**os.environ, "PYTHONIOENCODING": "utf-8"},
                 )
-                stdout_lines = 0
-                stderr_lines = 0
-
-                def stream_output(stream, file_obj, report_func, count_func):
-                    nonlocal stdout_lines, stderr_lines
-                    for line in stream:
-                        file_obj.write(line)
-                        file_obj.flush()
-                        report_func(line)
-                        if count_func == "stdout":
-                            stdout_lines += 1
-                        else:
-                            stderr_lines += 1
-
-                stdout_thread = threading.Thread(
-                    target=stream_output,
-                    args=(process.stdout, stdout_file, self.report_stdout, "stdout"),
+                stdout_lines, stderr_lines = self._stream_process_output(
+                    process, stdout_file, stderr_file, code
                 )
-                stderr_thread = threading.Thread(
-                    target=stream_output,
-                    args=(process.stderr, stderr_file, self.report_stderr, "stderr"),
-                )
-                stdout_thread.start()
-                stderr_thread.start()
-                try:
-                    process.stdin.write(code)
-                    process.stdin.close()
-                    return_code = process.wait(timeout=timeout)
-                except subprocess.TimeoutExpired:
-                    process.kill()
-                    self.report_error(
-                        tr("\u274c Timed out after {timeout} seconds.", timeout=timeout)
-                    )
+                return_code = self._wait_for_process(process, timeout)
+                if return_code is None:
                     return tr(
                         "Code timed out after {timeout} seconds.", timeout=timeout
                     )
-                stdout_thread.join()
-                stderr_thread.join()
                 stdout_file.flush()
                 stderr_file.flush()
-
                 self.report_success(
                     tr("\u2705 Return code {return_code}", return_code=return_code)
                 )
-                # Read back the content for summary if not too large
-                with open(
-                    stdout_file.name, "r", encoding="utf-8", errors="replace"
-                ) as out_f:
-                    stdout_content = out_f.read()
-                with open(
-                    stderr_file.name, "r", encoding="utf-8", errors="replace"
-                ) as err_f:
-                    stderr_content = err_f.read()
-                max_lines = 100
-                stdout_lines = stdout_content.count("\n")
-                stderr_lines = stderr_content.count("\n")
-
-                def head_tail(text, n=10):
-                    lines = text.splitlines()
-                    if len(lines) <= 2 * n:
-                        return "\n".join(lines)
-                    return "\n".join(
-                        lines[:n]
-                        + ["... ({} lines omitted) ...".format(len(lines) - 2 * n)]
-                        + lines[-n:]
-                    )
-
-                if stdout_lines <= max_lines and stderr_lines <= max_lines:
-                    result = (
-                        f"Return code: {return_code}\n--- STDOUT ---\n{stdout_content}"
-                    )
-                    if stderr_content.strip():
-                        result += f"\n--- STDERR ---\n{stderr_content}"
-                    return result
-                else:
-                    result = (
-                        f"stdout_file: {stdout_file.name} (lines: {stdout_lines})\n"
-                    )
-                    if stderr_lines > 0 and stderr_content.strip():
-                        result += (
-                            f"stderr_file: {stderr_file.name} (lines: {stderr_lines})\n"
-                        )
-                    result += f"returncode: {return_code}\n"
-                    result += (
-                        "--- STDOUT (head/tail) ---\n"
-                        + head_tail(stdout_content)
-                        + "\n"
-                    )
-                    if stderr_content.strip():
-                        result += (
-                            "--- STDERR (head/tail) ---\n"
-                            + head_tail(stderr_content)
-                            + "\n"
-                        )
-                    result += "Use the get_lines tool to inspect the contents of these files when needed."
-                    return result
+                return self._format_result(
+                    stdout_file.name, stderr_file.name, return_code
+                )
         except Exception as e:
             self.report_error(tr("\u274c Error: {error}", error=e))
             return tr("Error running code via stdin: {error}", error=e)
+
+    def _stream_process_output(self, process, stdout_file, stderr_file, code):
+        stdout_lines = 0
+        stderr_lines = 0
+
+        def stream_output(stream, file_obj, report_func, count_func):
+            nonlocal stdout_lines, stderr_lines
+            for line in stream:
+                file_obj.write(line)
+                file_obj.flush()
+                report_func(line)
+                if count_func == "stdout":
+                    stdout_lines += 1
+                else:
+                    stderr_lines += 1
+
+        stdout_thread = threading.Thread(
+            target=stream_output,
+            args=(process.stdout, stdout_file, self.report_stdout, "stdout"),
+        )
+        stderr_thread = threading.Thread(
+            target=stream_output,
+            args=(process.stderr, stderr_file, self.report_stderr, "stderr"),
+        )
+        stdout_thread.start()
+        stderr_thread.start()
+        process.stdin.write(code)
+        process.stdin.close()
+        stdout_thread.join()
+        stderr_thread.join()
+        return stdout_lines, stderr_lines
+
+    def _wait_for_process(self, process, timeout):
+        try:
+            return process.wait(timeout=timeout)
+        except subprocess.TimeoutExpired:
+            process.kill()
+            self.report_error(
+                tr("\u274c Timed out after {timeout} seconds.", timeout=timeout)
+            )
+            return None
+
+    def _format_result(self, stdout_file_name, stderr_file_name, return_code):
+        with open(stdout_file_name, "r", encoding="utf-8", errors="replace") as out_f:
+            stdout_content = out_f.read()
+        with open(stderr_file_name, "r", encoding="utf-8", errors="replace") as err_f:
+            stderr_content = err_f.read()
+        max_lines = 100
+        stdout_lines = stdout_content.count("\n")
+        stderr_lines = stderr_content.count("\n")
+
+        def head_tail(text, n=10):
+            lines = text.splitlines()
+            if len(lines) <= 2 * n:
+                return "\n".join(lines)
+            return "\n".join(
+                lines[:n]
+                + ["... ({} lines omitted) ...".format(len(lines) - 2 * n)]
+                + lines[-n:]
+            )
+
+        if stdout_lines <= max_lines and stderr_lines <= max_lines:
+            result = f"Return code: {return_code}\n--- STDOUT ---\n{stdout_content}"
+            if stderr_content.strip():
+                result += f"\n--- STDERR ---\n{stderr_content}"
+            return result
+        else:
+            result = f"stdout_file: {stdout_file_name} (lines: {stdout_lines})\n"
+            if stderr_lines > 0 and stderr_content.strip():
+                result += f"stderr_file: {stderr_file_name} (lines: {stderr_lines})\n"
+            result += f"returncode: {return_code}\n"
+            result += "--- STDOUT (head/tail) ---\n" + head_tail(stdout_content) + "\n"
+            if stderr_content.strip():
+                result += (
+                    "--- STDERR (head/tail) ---\n" + head_tail(stderr_content) + "\n"
+                )
+            result += "Use the get_lines tool to inspect the contents of these files when needed."
+            return result

janito/agent/tools/remove_directory.py

@@ -26,7 +26,7 @@ class RemoveDirectoryTool(ToolBase):
         disp_path = display_path(file_path)
         self.report_info(
             ActionType.WRITE,
-            tr("🗃️ Removing directory '{disp_path}' ...", disp_path=disp_path),
+            tr("🗃️ Remove directory '{disp_path}' ...", disp_path=disp_path),
         )
         backup_zip = None
         try:

janito/agent/tools/remove_file.py

@@ -31,7 +31,7 @@ class RemoveFileTool(ToolBase):
         # Report initial info about what is going to be removed
         self.report_info(
             ActionType.WRITE,
-            tr("🗑️ Removing file '{disp_path}' ...", disp_path=disp_path),
+            tr("🗑️ Remove file '{disp_path}' ...", disp_path=disp_path),
         )
         if not os.path.exists(path):
             self.report_error(tr("❌ File does not exist."))

janito/agent/tools/replace_file.py

@@ -39,7 +39,7 @@ class ReplaceFileTool(ToolBase):
         if not tracker.last_operation_is_full_read_or_replace(file_path):
             self.report_info(
                 ActionType.WRITE,
-                tr("📝 Replacing file '{disp_path}' ...", disp_path=disp_path),
+                tr("📝 Replace file '{disp_path}' ...", disp_path=disp_path),
             )
             self.report_warning(tr("ℹ️ Missing full view."))
             try:
@@ -54,7 +54,7 @@ class ReplaceFileTool(ToolBase):
             )
         self.report_info(
             ActionType.WRITE,
-            tr("📝 Replacing file '{disp_path}' ...", disp_path=disp_path),
+            tr("📝 Replace file '{disp_path}' ...", disp_path=disp_path),
         )
         backup_path = file_path + ".bak"
         shutil.copy2(file_path, backup_path)