janito 1.14.3__py3-none-any.whl → 2.0.1__py3-none-any.whl

janito/agent/tools/python_file_runner.py

@@ -1,199 +0,0 @@
-import subprocess
-import os
-import sys
-import tempfile
-import threading
-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")
-class PythonFileRunnerTool(ToolBase):
-    """
-    Tool to execute a specified Python script file.
-    Args:
-        file_path (str): Path to the Python script file to execute.
-        timeout (int, optional): Timeout in seconds for the command. Defaults to 60.
-    Returns:
-        str: Output and status message, or file paths/line counts if output is large.
-    """
-
-    def run(self, file_path: str, timeout: int = 60) -> str:
-        self.report_info(
-            ActionType.EXECUTE,
-            tr("680 Running: python {file_path}", file_path=file_path),
-        )
-        try:
-            if runtime_config.get("all_out"):
-                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_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),
-                )
-                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_thread.join()
-                stderr_thread.join()
-                self.report_success(
-                    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("534 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("6d1 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,208 +0,0 @@
-import subprocess
-import os
-import sys
-import tempfile
-import threading
-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")
-class PythonStdinRunnerTool(ToolBase):
-    """
-    Tool to execute Python code by passing it to the interpreter via standard input (stdin).
-    Args:
-        code (str): The Python code to execute as a string.
-        timeout (int, optional): Timeout in seconds for the command. Defaults to 60.
-    Returns:
-        str: Output and status message, or file paths/line counts if output is large.
-    """
-
-    def run(self, code: str, timeout: int = 60) -> str:
-        if not code.strip():
-            self.report_warning(tr("ℹ️ Empty code provided."))
-            return tr("Warning: Empty code provided. Operation skipped.")
-        self.report_info(
-            ActionType.EXECUTE,
-            tr("5e1 Running: python (stdin mode) ...\n{code}\n", code=code),
-        )
-        try:
-            if runtime_config.get("all_out"):
-                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_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),
-                )
-                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_thread.join()
-                stderr_thread.join()
-                self.report_success(
-                    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("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):
-        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("6d1 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/replace_file.py

@@ -1,72 +0,0 @@
-import os
-import shutil
-from janito.agent.tool_registry import register_tool
-from janito.agent.tools_utils.utils import display_path
-from janito.agent.tool_base import ToolBase
-from janito.agent.tools_utils.action_type import ActionType
-from janito.i18n import tr
-
-from janito.agent.tools.validate_file_syntax.core import validate_file_syntax
-
-
-@register_tool(name="replace_file")
-class ReplaceFileTool(ToolBase):
-    """
-    Replace the entire content of an existing file. Fails if the file does not exist.
-    Args:
-        file_path (str): Path to the file to replace content.
-        content (str): The full new content to write to the file. You must provide the complete content as it will fully overwrite the existing file—do not use placeholders for original content.
-    Returns:
-        str: Status message indicating the result. Example:
-            - "✅ Successfully replaced the file at ..."
-
-    Note: Syntax validation is automatically performed after this operation.
-    """
-
-    def run(self, file_path: str, content: str) -> str:
-        from janito.agent.tool_use_tracker import ToolUseTracker
-
-        expanded_file_path = file_path  # Using file_path as is
-        disp_path = display_path(expanded_file_path)
-        file_path = expanded_file_path
-        if not os.path.exists(file_path):
-            return tr(
-                "❗ Cannot replace: file does not exist at '{disp_path}'.",
-                disp_path=disp_path,
-            )
-        # Check previous operation
-        tracker = ToolUseTracker()
-        if not tracker.last_operation_is_full_read_or_replace(file_path):
-            self.report_info(
-                ActionType.WRITE,
-                tr("📝 Replace file '{disp_path}' ...", disp_path=disp_path),
-            )
-            self.report_warning(tr("ℹ️ Missing full view."))
-            try:
-                with open(file_path, "r", encoding="utf-8", errors="replace") as f:
-                    current_content = f.read()
-            except Exception as e:
-                current_content = f"[Error reading file: {e}]"
-            return (
-                "⚠️ [missing full view] Update was NOT performed. The full content of the file is included below for your review. Repeat the operation if you wish to proceed.\n"
-                f"--- Current content of {disp_path} ---\n"
-                f"{current_content}"
-            )
-        self.report_info(
-            ActionType.WRITE,
-            tr("📝 Replace file '{disp_path}' ...", disp_path=disp_path),
-        )
-        backup_path = file_path + ".bak"
-        shutil.copy2(file_path, backup_path)
-        with open(file_path, "w", encoding="utf-8", errors="replace") as f:
-            f.write(content)
-        new_lines = content.count("\n") + 1 if content else 0
-        self.report_success(tr("✅ {new_lines} lines", new_lines=new_lines))
-        msg = tr(
-            "✅ Replaced file ({new_lines} lines, backup at {backup_path}).",
-            new_lines=new_lines,
-            backup_path=backup_path,
-        )
-        # Perform syntax validation and append result
-        validation_result = validate_file_syntax(file_path)
-        return msg + f"\n{validation_result}"