janito 1.12.2__py3-none-any.whl → 1.13.1__py3-none-any.whl

janito/__init__.py

@@ -1 +1 @@
-__version__ = "1.12.2"
+__version__ = "1.13.1"

janito/agent/tools/python_command_runner.py

@@ -7,6 +7,7 @@ from janito.agent.tool_base import ToolBase
 from janito.agent.tools_utils.action_type import ActionType
 from janito.agent.tool_registry import register_tool
 from janito.i18n import tr
+from janito.agent.runtime_config import runtime_config
 
 
 @register_tool(name="python_command_runner")
@@ -22,26 +23,13 @@ class PythonCommandRunnerTool(ToolBase):
 
     def run(self, code: str, timeout: int = 60) -> str:
         if not code.strip():
-            self.report_warning(tr("ℹ️ Empty code provided."))
+            self.report_warning(tr("539 Empty code provided."))
             return tr("Warning: Empty code provided. Operation skipped.")
         self.report_info(
-            ActionType.EXECUTE, tr("🐍 Running: python -c ...\n{code}\n", code=code)
+            ActionType.EXECUTE, tr("40d Running: python -c ...\n{code}\n", code=code)
         )
         try:
-            with (
-                tempfile.NamedTemporaryFile(
-                    mode="w+",
-                    prefix="python_cmd_stdout_",
-                    delete=False,
-                    encoding="utf-8",
-                ) as stdout_file,
-                tempfile.NamedTemporaryFile(
-                    mode="w+",
-                    prefix="python_cmd_stderr_",
-                    delete=False,
-                    encoding="utf-8",
-                ) as stderr_file,
-            ):
+            if runtime_config.get("all_out"):
                 process = subprocess.Popen(
                     [sys.executable, "-c", code],
                     stdout=subprocess.PIPE,
@@ -52,24 +40,88 @@ class PythonCommandRunnerTool(ToolBase):
                     encoding="utf-8",
                     env={**os.environ, "PYTHONIOENCODING": "utf-8"},
                 )
-                stdout_lines, stderr_lines = self._stream_process_output(
-                    process, stdout_file, stderr_file
+                stdout_accum = []
+                stderr_accum = []
+
+                def read_stream(stream, report_func, accum):
+                    for line in stream:
+                        accum.append(line)
+                        report_func(line)
+
+                stdout_thread = threading.Thread(
+                    target=read_stream,
+                    args=(process.stdout, self.report_stdout, stdout_accum),
+                )
+                stderr_thread = threading.Thread(
+                    target=read_stream,
+                    args=(process.stderr, self.report_stderr, stderr_accum),
                 )
-                return_code = self._wait_for_process(process, timeout)
-                if return_code is None:
+                stdout_thread.start()
+                stderr_thread.start()
+                try:
+                    return_code = process.wait(timeout=timeout)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                    self.report_error(
+                        tr("6d1 Timed out after {timeout} seconds.", timeout=timeout)
+                    )
                     return tr(
                         "Code timed out after {timeout} seconds.", timeout=timeout
                     )
-                stdout_file.flush()
-                stderr_file.flush()
+                stdout_thread.join()
+                stderr_thread.join()
                 self.report_success(
-                    tr("✅ Return code {return_code}", return_code=return_code)
-                )
-                return self._format_result(
-                    stdout_file.name, stderr_file.name, return_code
+                    tr("197 Return code {return_code}", return_code=return_code)
                 )
+                stdout = "".join(stdout_accum)
+                stderr = "".join(stderr_accum)
+                result = f"Return code: {return_code}\n--- STDOUT ---\n{stdout}"
+                if stderr and stderr.strip():
+                    result += f"\n--- STDERR ---\n{stderr}"
+                return result
+            else:
+                with (
+                    tempfile.NamedTemporaryFile(
+                        mode="w+",
+                        prefix="python_cmd_stdout_",
+                        delete=False,
+                        encoding="utf-8",
+                    ) as stdout_file,
+                    tempfile.NamedTemporaryFile(
+                        mode="w+",
+                        prefix="python_cmd_stderr_",
+                        delete=False,
+                        encoding="utf-8",
+                    ) as stderr_file,
+                ):
+                    process = subprocess.Popen(
+                        [sys.executable, "-c", code],
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.PIPE,
+                        text=True,
+                        bufsize=1,
+                        universal_newlines=True,
+                        encoding="utf-8",
+                        env={**os.environ, "PYTHONIOENCODING": "utf-8"},
+                    )
+                    stdout_lines, stderr_lines = self._stream_process_output(
+                        process, stdout_file, stderr_file
+                    )
+                    return_code = self._wait_for_process(process, timeout)
+                    if return_code is None:
+                        return tr(
+                            "Code timed out after {timeout} seconds.", timeout=timeout
+                        )
+                    stdout_file.flush()
+                    stderr_file.flush()
+                    self.report_success(
+                        tr("197 Return code {return_code}", return_code=return_code)
+                    )
+                    return self._format_result(
+                        stdout_file.name, stderr_file.name, return_code
+                    )
         except Exception as e:
-            self.report_error(tr("❌ Error: {error}", error=e))
+            self.report_error(tr("534 Error: {error}", error=e))
             return tr("Error running code: {error}", error=e)
 
     def _stream_process_output(self, process, stdout_file, stderr_file):
@@ -107,7 +159,7 @@ class PythonCommandRunnerTool(ToolBase):
         except subprocess.TimeoutExpired:
             process.kill()
             self.report_error(
-                tr("❌ Timed out after {timeout} seconds.", timeout=timeout)
+                tr("6d1 Timed out after {timeout} seconds.", timeout=timeout)
             )
             return None
 

janito/agent/tools/python_file_runner.py

@@ -7,6 +7,7 @@ from janito.agent.tool_base import ToolBase
 from janito.agent.tools_utils.action_type import ActionType
 from janito.agent.tool_registry import register_tool
 from janito.i18n import tr
+from janito.agent.runtime_config import runtime_config
 
 
 @register_tool(name="python_file_runner")
@@ -23,23 +24,10 @@ class PythonFileRunnerTool(ToolBase):
     def run(self, file_path: str, timeout: int = 60) -> str:
         self.report_info(
             ActionType.EXECUTE,
-            tr("🚀 Running: python {file_path}", file_path=file_path),
+            tr("680 Running: python {file_path}", file_path=file_path),
         )
         try:
-            with (
-                tempfile.NamedTemporaryFile(
-                    mode="w+",
-                    prefix="python_file_stdout_",
-                    delete=False,
-                    encoding="utf-8",
-                ) as stdout_file,
-                tempfile.NamedTemporaryFile(
-                    mode="w+",
-                    prefix="python_file_stderr_",
-                    delete=False,
-                    encoding="utf-8",
-                ) as stderr_file,
-            ):
+            if runtime_config.get("all_out"):
                 process = subprocess.Popen(
                     [sys.executable, file_path],
                     stdout=subprocess.PIPE,
@@ -50,24 +38,88 @@ class PythonFileRunnerTool(ToolBase):
                     encoding="utf-8",
                     env={**os.environ, "PYTHONIOENCODING": "utf-8"},
                 )
-                stdout_lines, stderr_lines = self._stream_process_output(
-                    process, stdout_file, stderr_file
+                stdout_accum = []
+                stderr_accum = []
+
+                def read_stream(stream, report_func, accum):
+                    for line in stream:
+                        accum.append(line)
+                        report_func(line)
+
+                stdout_thread = threading.Thread(
+                    target=read_stream,
+                    args=(process.stdout, self.report_stdout, stdout_accum),
+                )
+                stderr_thread = threading.Thread(
+                    target=read_stream,
+                    args=(process.stderr, self.report_stderr, stderr_accum),
                 )
-                return_code = self._wait_for_process(process, timeout)
-                if return_code is None:
+                stdout_thread.start()
+                stderr_thread.start()
+                try:
+                    return_code = process.wait(timeout=timeout)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                    self.report_error(
+                        tr("6d1 Timed out after {timeout} seconds.", timeout=timeout)
+                    )
                     return tr(
                         "Code timed out after {timeout} seconds.", timeout=timeout
                     )
-                stdout_file.flush()
-                stderr_file.flush()
+                stdout_thread.join()
+                stderr_thread.join()
                 self.report_success(
-                    tr("✅ Return code {return_code}", return_code=return_code)
-                )
-                return self._format_result(
-                    stdout_file.name, stderr_file.name, return_code
+                    tr("197 Return code {return_code}", return_code=return_code)
                 )
+                stdout = "".join(stdout_accum)
+                stderr = "".join(stderr_accum)
+                result = f"Return code: {return_code}\n--- STDOUT ---\n{stdout}"
+                if stderr and stderr.strip():
+                    result += f"\n--- STDERR ---\n{stderr}"
+                return result
+            else:
+                with (
+                    tempfile.NamedTemporaryFile(
+                        mode="w+",
+                        prefix="python_file_stdout_",
+                        delete=False,
+                        encoding="utf-8",
+                    ) as stdout_file,
+                    tempfile.NamedTemporaryFile(
+                        mode="w+",
+                        prefix="python_file_stderr_",
+                        delete=False,
+                        encoding="utf-8",
+                    ) as stderr_file,
+                ):
+                    process = subprocess.Popen(
+                        [sys.executable, file_path],
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.PIPE,
+                        text=True,
+                        bufsize=1,
+                        universal_newlines=True,
+                        encoding="utf-8",
+                        env={**os.environ, "PYTHONIOENCODING": "utf-8"},
+                    )
+                    stdout_lines, stderr_lines = self._stream_process_output(
+                        process, stdout_file, stderr_file
+                    )
+                    return_code = self._wait_for_process(process, timeout)
+                    if return_code is None:
+                        return tr(
+                            "Code timed out after {timeout} seconds.", timeout=timeout
+                        )
+                    stdout_file.flush()
+                    stderr_file.flush()
+                    self.report_success(
+                        tr("197 Return code {return_code}", return_code=return_code)
+                    )
+                    return self._format_result(
+                        stdout_file.name, stderr_file.name, return_code
+                    )
         except Exception as e:
-            self.report_error(tr("❌ Error: {error}", error=e))
+            self.report_error(tr("534 Error: {error}", error=e))
             return tr("Error running file: {error}", error=e)
 
     def _stream_process_output(self, process, stdout_file, stderr_file):
@@ -105,7 +157,7 @@ class PythonFileRunnerTool(ToolBase):
         except subprocess.TimeoutExpired:
             process.kill()
             self.report_error(
-                tr("❌ Timed out after {timeout} seconds.", timeout=timeout)
+                tr("6d1 Timed out after {timeout} seconds.", timeout=timeout)
             )
             return None
 

janito/agent/tools/python_stdin_runner.py

@@ -7,6 +7,7 @@ from janito.agent.tool_base import ToolBase
 from janito.agent.tools_utils.action_type import ActionType
 from janito.agent.tool_registry import register_tool
 from janito.i18n import tr
+from janito.agent.runtime_config import runtime_config
 
 
 @register_tool(name="python_stdin_runner")
@@ -22,27 +23,14 @@ class PythonStdinRunnerTool(ToolBase):
 
     def run(self, code: str, timeout: int = 60) -> str:
         if not code.strip():
-            self.report_warning(tr("\u2139\ufe0f Empty code provided."))
+            self.report_warning(tr("ℹ️ Empty code provided."))
             return tr("Warning: Empty code provided. Operation skipped.")
         self.report_info(
             ActionType.EXECUTE,
-            tr("⚡ Running: python (stdin mode) ...\n{code}\n", code=code),
+            tr("5e1 Running: python (stdin mode) ...\n{code}\n", code=code),
         )
         try:
-            with (
-                tempfile.NamedTemporaryFile(
-                    mode="w+",
-                    prefix="python_stdin_stdout_",
-                    delete=False,
-                    encoding="utf-8",
-                ) as stdout_file,
-                tempfile.NamedTemporaryFile(
-                    mode="w+",
-                    prefix="python_stdin_stderr_",
-                    delete=False,
-                    encoding="utf-8",
-                ) as stderr_file,
-            ):
+            if runtime_config.get("all_out"):
                 process = subprocess.Popen(
                     [sys.executable],
                     stdin=subprocess.PIPE,
@@ -54,24 +42,91 @@ class PythonStdinRunnerTool(ToolBase):
                     encoding="utf-8",
                     env={**os.environ, "PYTHONIOENCODING": "utf-8"},
                 )
-                stdout_lines, stderr_lines = self._stream_process_output(
-                    process, stdout_file, stderr_file, code
+                stdout_accum = []
+                stderr_accum = []
+
+                def read_stream(stream, report_func, accum):
+                    for line in stream:
+                        accum.append(line)
+                        report_func(line)
+
+                stdout_thread = threading.Thread(
+                    target=read_stream,
+                    args=(process.stdout, self.report_stdout, stdout_accum),
+                )
+                stderr_thread = threading.Thread(
+                    target=read_stream,
+                    args=(process.stderr, self.report_stderr, stderr_accum),
                 )
-                return_code = self._wait_for_process(process, timeout)
-                if return_code is None:
+                stdout_thread.start()
+                stderr_thread.start()
+                process.stdin.write(code)
+                process.stdin.close()
+                try:
+                    return_code = process.wait(timeout=timeout)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                    self.report_error(
+                        tr("6d1 Timed out after {timeout} seconds.", timeout=timeout)
+                    )
                     return tr(
                         "Code timed out after {timeout} seconds.", timeout=timeout
                     )
-                stdout_file.flush()
-                stderr_file.flush()
+                stdout_thread.join()
+                stderr_thread.join()
                 self.report_success(
-                    tr("\u2705 Return code {return_code}", return_code=return_code)
-                )
-                return self._format_result(
-                    stdout_file.name, stderr_file.name, return_code
+                    tr("197 Return code {return_code}", return_code=return_code)
                 )
+                stdout = "".join(stdout_accum)
+                stderr = "".join(stderr_accum)
+                result = f"Return code: {return_code}\n--- STDOUT ---\n{stdout}"
+                if stderr and stderr.strip():
+                    result += f"\n--- STDERR ---\n{stderr}"
+                return result
+            else:
+                with (
+                    tempfile.NamedTemporaryFile(
+                        mode="w+",
+                        prefix="python_stdin_stdout_",
+                        delete=False,
+                        encoding="utf-8",
+                    ) as stdout_file,
+                    tempfile.NamedTemporaryFile(
+                        mode="w+",
+                        prefix="python_stdin_stderr_",
+                        delete=False,
+                        encoding="utf-8",
+                    ) as stderr_file,
+                ):
+                    process = subprocess.Popen(
+                        [sys.executable],
+                        stdin=subprocess.PIPE,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.PIPE,
+                        text=True,
+                        bufsize=1,
+                        universal_newlines=True,
+                        encoding="utf-8",
+                        env={**os.environ, "PYTHONIOENCODING": "utf-8"},
+                    )
+                    stdout_lines, stderr_lines = self._stream_process_output(
+                        process, stdout_file, stderr_file, code
+                    )
+                    return_code = self._wait_for_process(process, timeout)
+                    if return_code is None:
+                        return tr(
+                            "Code timed out after {timeout} seconds.", timeout=timeout
+                        )
+                    stdout_file.flush()
+                    stderr_file.flush()
+                    self.report_success(
+                        tr("197 Return code {return_code}", return_code=return_code)
+                    )
+                    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))
+            self.report_error(tr("534 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):
@@ -111,7 +166,7 @@ class PythonStdinRunnerTool(ToolBase):
         except subprocess.TimeoutExpired:
             process.kill()
             self.report_error(
-                tr("\u274c Timed out after {timeout} seconds.", timeout=timeout)
+                tr("6d1 Timed out after {timeout} seconds.", timeout=timeout)
             )
             return None
 

janito/agent/tools/replace_text_in_file.py

@@ -93,7 +93,7 @@ class ReplaceTextInFileTool(ToolBase):
                 final_msg += f"\n{validation_result}"
             return final_msg
         except Exception as e:
-            self.report_error(tr(" \u274c Error"))
+            self.report_error(tr(" ❌ Error"))
             return tr("Error replacing text: {error}", error=e)
 
     def _read_file_content(self, file_path):
@@ -147,12 +147,12 @@ class ReplaceTextInFileTool(ToolBase):
         if replaced_count == 0:
             warning = tr(" [Warning: Search text not found in file]")
         if not file_changed:
-            self.report_warning(tr(" \u2139\ufe0f No changes made. [not found]"))
+            self.report_warning(tr(" ℹ️ No changes made. [not found]"))
             concise_warning = tr(
                 "No changes made. The search text was not found. Expand your search context with surrounding lines if needed."
             )
         if occurrences > 1 and replaced_count == 0:
-            self.report_warning(tr(" \u2139\ufe0f No changes made. [not unique]"))
+            self.report_warning(tr(" ℹ️ No changes made. [not unique]"))
             concise_warning = tr(
                 "No changes made. The search text is not unique. Expand your search context with surrounding lines to ensure uniqueness."
             )
@@ -162,11 +162,9 @@ class ReplaceTextInFileTool(ToolBase):
         """Report success with line numbers where replacements occurred."""
         if match_lines:
             lines_str = ", ".join(str(line_no) for line_no in match_lines)
-            self.report_success(
-                tr(" \u2705 replaced at {lines_str}", lines_str=lines_str)
-            )
+            self.report_success(tr(" ✅ replaced at {lines_str}", lines_str=lines_str))
         else:
-            self.report_success(tr(" \u2705 replaced (lines unknown)"))
+            self.report_success(tr(" ✅ replaced (lines unknown)"))
 
     def _get_line_delta_str(self, content, new_content):
         """Return a string describing the net line change after replacement."""