janito 3.5.0__py3-none-any.whl → 3.6.1__py3-none-any.whl

janito/plugins/dev/pythondev/tools/python_file_run.py

@@ -1,172 +0,0 @@
-import subprocess
-import os
-import sys
-import tempfile
-import threading
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.report_events import ReportAction
-from janito.tools.adapters.local.adapter import register_local_tool
-from janito.i18n import tr
-
-
-@register_local_tool
-class PythonFileRunTool(ToolBase):
-    """
-    Tool to execute a specified Python script file.
-
-    Args:
-        path (str): Path to the Python script file to execute.
-        timeout (int): Timeout in seconds for the command. Defaults to 60.
-        silent (bool): If True, suppresses progress and status messages. Defaults to False.
-
-    Returns:
-        str: Output and status message, or file paths/line counts if output is large.
-    """
-
-    permissions = ToolPermissions(execute=True)
-    tool_name = "python_file_run"
-
-    def run(self, path: str, timeout: int = 60, silent: bool = False) -> str:
-        from janito.tools.path_utils import expand_path
-
-        path = expand_path(path)
-        if not silent:
-            self.report_action(
-                tr("🚀 Running: python {path}", path=path),
-                ReportAction.EXECUTE,
-            )
-            self.report_stdout("\n")
-        else:
-            self.report_action(tr("⚡ Executing..."), ReportAction.EXECUTE)
-        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,
-            ):
-                process = subprocess.Popen(
-                    [sys.executable, 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()
-                if not silent:
-                    self.report_success(
-                        tr("✅ Return code {return_code}", return_code=return_code),
-                        ReportAction.EXECUTE,
-                    )
-                return self._format_result(
-                    stdout_file.name, stderr_file.name, return_code
-                )
-        except Exception as e:
-            self.report_error(tr("❌ Error: {error}", error=e), ReportAction.EXECUTE)
-            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()
-                # Always supply a default action for stdout/stderr reporting
-                from janito.report_events import ReportAction
-
-                report_func(line.rstrip("\r\n"), ReportAction.EXECUTE)
-                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("❌ Timed out after {timeout} seconds.", timeout=timeout),
-                ReportAction.EXECUTE,
-            )
-            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--- python_file_run: STDOUT ---\n{stdout_content}"
-            if stderr_content.strip():
-                result += f"\n--- python_file_run: 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 += (
-                "--- python_file_run: STDOUT (head/tail) ---\n"
-                + head_tail(stdout_content)
-                + "\n"
-            )
-            if stderr_content.strip():
-                result += (
-                    "--- python_file_run: STDERR (head/tail) ---\n"
-                    + head_tail(stderr_content)
-                    + "\n"
-                )
-            result += "Use the view_file tool to inspect the contents of these files when needed."
-            return result

janito/plugins/tools/core_tools_plugin.py

@@ -1,87 +0,0 @@
-"""
-Core tools plugin implementation.
-"""
-
-from functools import wraps
-from typing import Type
-from janito.plugin_system.base import Plugin, PluginMetadata
-
-from .ask_user import AskUser
-from .copy_file import CopyFile
-from .create_directory import CreateDirectory
-from .create_file import CreateFile
-from .delete_text_in_file import DeleteTextInFile
-from .fetch_url import FetchUrl
-from .find_files import FindFiles
-from .move_file import MoveFile
-from .open_html_in_browser import OpenHtmlInBrowser
-from .open_url import OpenUrl
-from .python_code_run import PythonCodeRun
-from .python_command_run import PythonCommandRun
-from .python_file_run import PythonFileRun
-from .read_chart import ReadChart
-from .read_files import ReadFiles
-from .remove_directory import RemoveDirectory
-from .remove_file import RemoveFile
-from .replace_text_in_file import ReplaceTextInFile
-from .run_bash_command import RunBashCommand
-from .run_powershell_command import RunPowershellCommand
-from .show_image import ShowImage
-from .show_image_grid import ShowImageGrid
-from .view_file import ViewFile
-from .validate_file_syntax.core import ValidateFileSyntax
-from .get_file_outline.core import GetFileOutline
-from .search_text.core import SearchText
-from .decorators import get_core_tools
-
-# Registry for core tools
-_core_tools_registry = []
-
-
-def register_core_tool(cls: Type):
-    """Decorator to register a core tool."""
-    _core_tools_registry.append(cls)
-    return cls
-
-
-class CoreToolsPlugin(Plugin):
-    """Core tools plugin providing essential janito functionality."""
-
-    def get_metadata(self):
-        return PluginMetadata(
-            name="core_tools",
-            version="1.0.0",
-            description="Core tools for file operations, code execution, and system interactions",
-            author="janito team",
-            license="MIT",
-        )
-
-    def get_tools(self):
-        return [
-            AskUser,
-            CopyFile,
-            CreateDirectory,
-            CreateFile,
-            DeleteTextInFile,
-            FetchUrl,
-            FindFiles,
-            MoveFile,
-            OpenHtmlInBrowser,
-            OpenUrl,
-            PythonCodeRun,
-            PythonCommandRun,
-            PythonFileRun,
-            ReadChart,
-            ReadFiles,
-            RemoveDirectory,
-            RemoveFile,
-            ReplaceTextInFile,
-            RunBashCommand,
-            RunPowershellCommand,
-            ShowImage,
-            ShowImageGrid,
-            ViewFile,
-            ValidateFileSyntax,
-            GetFileOutline,
-            SearchText,
-        ] + get_core_tools()