janito 2.2.0__py3-none-any.whl → 2.3.0__py3-none-any.whl

janito/tools/adapters/local/python_file_run.py

@@ -1,163 +1,163 @@
-import subprocess
-import os
-import sys
-import tempfile
-import threading
-from janito.tools.tool_base import ToolBase
-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.
-
-    Parameters:
-        file_path (str): Path to the Python script file to execute.
-        timeout (int): Timeout in seconds for the command. Defaults to 60.
-
-    Returns:
-        str: Output and status message, or file paths/line counts if output is large.
-    """
-    provides_execution = True
-    tool_name = "python_file_run"
-
-    def run(self, file_path: str, timeout: int = 60) -> str:
-        self.report_action(
-            tr("🚀 Running: python {file_path}", file_path=file_path),
-            ReportAction.EXECUTE,
-        )
-        self.report_stdout("\n")
-        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, 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("✅ 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
+import subprocess
+import os
+import sys
+import tempfile
+import threading
+from janito.tools.tool_base import ToolBase
+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.
+
+    Parameters:
+        file_path (str): Path to the Python script file to execute.
+        timeout (int): Timeout in seconds for the command. Defaults to 60.
+
+    Returns:
+        str: Output and status message, or file paths/line counts if output is large.
+    """
+    provides_execution = True
+    tool_name = "python_file_run"
+
+    def run(self, file_path: str, timeout: int = 60) -> str:
+        self.report_action(
+            tr("🚀 Running: python {file_path}", file_path=file_path),
+            ReportAction.EXECUTE,
+        )
+        self.report_stdout("\n")
+        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, 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("✅ 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/tools/adapters/local/remove_directory.py

@@ -28,36 +28,25 @@ class RemoveDirectoryTool(ToolBase):
         disp_path = display_path(file_path)
         self.report_action(
             tr("🗃️ Remove directory '{disp_path}' ...", disp_path=disp_path),
-            ReportAction.CREATE,
+            ReportAction.DELETE,
         )
-        backup_zip = None
+
         try:
             if recursive:
-                # Backup before recursive removal
-                if os.path.exists(file_path) and os.path.isdir(file_path):
-                    backup_zip = file_path.rstrip("/\\") + ".bak.zip"
-                    with zipfile.ZipFile(backup_zip, "w", zipfile.ZIP_DEFLATED) as zipf:
-                        for root, dirs, files in os.walk(file_path):
-                            for file in files:
-                                abs_path = os.path.join(root, file)
-                                rel_path = os.path.relpath(
-                                    abs_path, os.path.dirname(file_path)
-                                )
-                                zipf.write(abs_path, rel_path)
+
                 shutil.rmtree(file_path)
             else:
                 os.rmdir(file_path)
             self.report_success(
                 tr("✅ 1 {dir_word}", dir_word=pluralize("directory", 1)),
-                ReportAction.CREATE,
+                ReportAction.DELETE,
             )
             msg = tr("Directory removed: {disp_path}", disp_path=disp_path)
-            if backup_zip:
-                msg += tr(" (backup at {backup_zip})", backup_zip=backup_zip)
+
             return msg
         except Exception as e:
             self.report_error(
                 tr(" ❌ Error removing directory: {error}", error=e),
-                ReportAction.REMOVE,
+                ReportAction.DELETE,
             )
             return tr("Error removing directory: {error}", error=e)

janito/tools/adapters/local/remove_file.py

@@ -15,7 +15,7 @@ class RemoveFileTool(ToolBase):
 
     Args:
         file_path (str): Path to the file to remove.
-        backup (bool, optional): If True, create a backup (.bak) before removing. Recommend using backup=True only in the first call to avoid redundant backups. Defaults to False.
+        backup (bool, optional): Deprecated. Backups are no longer created. Flag ignored.
     Returns:
         str: Status message indicating the result. Example:
             - "			 Successfully removed the file at ..."
@@ -28,7 +28,7 @@ class RemoveFileTool(ToolBase):
         original_path = file_path
         path = file_path  # Using file_path as is
         disp_path = display_path(original_path)
-        backup_path = None
+
         # Report initial info about what is going to be removed
         self.report_action(
             tr("🗑️ Remove file '{disp_path}' ...", disp_path=disp_path),
@@ -41,20 +41,14 @@ class RemoveFileTool(ToolBase):
             self.report_error(tr("❌ Path is not a file."), ReportAction.DELETE)
             return tr("❌ Path is not a file.")
         try:
-            if backup:
-                backup_path = path + ".bak"
-                shutil.copy2(path, backup_path)
+
             os.remove(path)
             self.report_success(tr("✅ File removed"), ReportAction.DELETE)
             msg = tr(
                 "✅ Successfully removed the file at '{disp_path}'.",
                 disp_path=disp_path,
             )
-            if backup_path:
-                msg += tr(
-                    " (backup at {backup_disp})",
-                    backup_disp=display_path(original_path + ".bak"),
-                )
+
             return msg
         except Exception as e:
             self.report_error(

janito/tools/adapters/local/replace_text_in_file.py

@@ -21,10 +21,10 @@ class ReplaceTextInFileTool(ToolBase):
         search_text (str): The exact text to search for (including indentation).
         replacement_text (str): The text to replace with (including indentation).
         replace_all (bool): If True, replace all occurrences; otherwise, only the first occurrence.
-        backup (bool, optional): If True, create a backup (.bak) before replacing. Recommend using backup=True only in the first call to avoid redundant backups. Defaults to False.
+        backup (bool, optional): Deprecated. No backups are created anymore and this flag is ignored. Defaults to False.
     Returns:
         str: Status message. Example:
-            - "Text replaced in /path/to/file (backup at /path/to/file.bak)"
+            - "Text replaced in /path/to/file"
             - "No changes made. [Warning: Search text not found in file] Please review the original file."
             - "Error replacing text: <error message>"
     """
@@ -63,9 +63,7 @@ class ReplaceTextInFileTool(ToolBase):
                 content, search_text, replacement_text, replace_all, occurrences
             )
             file_changed = new_content != content
-            backup_path = file_path + ".bak"
-            if backup and file_changed:
-                self._backup_file(file_path, backup_path)
+            backup_path = None
             validation_result = ""
             if file_changed:
                 self._write_file_content(file_path, new_content)
@@ -88,7 +86,7 @@ class ReplaceTextInFileTool(ToolBase):
                 replace_all,
             )
             return self._format_final_msg(
-                file_path, warning, backup_path, match_info, details
+                file_path, warning, match_info, details
             ) + (f"\n{validation_result}" if validation_result else "")
         except Exception as e:
             self.report_error(tr(" ❌ Error"), ReportAction.REPLACE)
@@ -260,13 +258,12 @@ class ReplaceTextInFileTool(ToolBase):
             details = ""
         return match_info, details
 
-    def _format_final_msg(self, file_path, warning, backup_path, match_info, details):
+    def _format_final_msg(self, file_path, warning, match_info, details):
         """Format the final status message."""
         return tr(
-            "Text replaced in {file_path}{warning} (backup at {backup_path}). {match_info}{details}",
+            "Text replaced in {file_path}{warning}. {match_info}{details}",
             file_path=file_path,
             warning=warning,
-            backup_path=backup_path,
             match_info=match_info,
             details=details,
         )