janito 3.3.0__py3-none-any.whl → 3.4.0__py3-none-any.whl

janito/plugins_backup_20250825_070018/core/filemanager/tools/delete_text_in_file.py

@@ -1,135 +0,0 @@
-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
-import shutil
-from janito.tools.adapters.local.validate_file_syntax.core import validate_file_syntax
-
-
-@register_local_tool
-class DeleteTextInFileTool(ToolBase):
-    """
-    Delete all occurrences of text between start_marker and end_marker (inclusive) in a file, using exact string markers.
-
-    Args:
-        path (str): Path to the file to modify.
-        start_marker (str): The starting delimiter string.
-        end_marker (str): The ending delimiter string.
-        backup (bool, optional): Deprecated. No backups are created anymore and this flag is ignored. Defaults to False.
-
-    Returns:
-        str: Status message indicating the result.
-    """
-
-    permissions = ToolPermissions(read=True, write=True)
-    tool_name = "delete_text_in_file"
-
-    def run(
-        self,
-        path: str,
-        start_marker: str,
-        end_marker: str,
-        backup: bool = False,
-    ) -> str:
-        from janito.tools.tool_utils import display_path
-
-        disp_path = display_path(path)
-        info_msg = tr(
-            "📝 Delete text in {disp_path} between markers: '{start_marker}' ... '{end_marker}'",
-            disp_path=disp_path,
-            start_marker=start_marker,
-            end_marker=end_marker,
-        )
-        self.report_action(info_msg, ReportAction.CREATE)
-        try:
-            content = self._read_file_content(path)
-            occurrences, match_lines = self._find_marker_blocks(
-                content, start_marker, end_marker
-            )
-            if occurrences == 0:
-                self.report_warning(
-                    tr(" ℹ️ No blocks found between markers."), ReportAction.CREATE
-                )
-                return tr(
-                    "No blocks found between markers in {path}.",
-                    path=path,
-                )
-
-            new_content, deleted_blocks = self._delete_blocks(
-                content, start_marker, end_marker
-            )
-            self._write_file_content(path, new_content)
-            validation_result = validate_file_syntax(path)
-            self._report_success(match_lines)
-            return tr(
-                "Deleted {count} block(s) between markers in {path}. ",
-                count=deleted_blocks,
-                path=path,
-            ) + (f"\n{validation_result}" if validation_result else "")
-        except Exception as e:
-            self.report_error(tr(" ❌ Error: {error}", error=e), ReportAction.REPLACE)
-            return tr("Error deleting text: {error}", error=e)
-
-    def _read_file_content(self, path):
-        with open(path, "r", encoding="utf-8", errors="replace") as f:
-            return f.read()
-
-    def _find_marker_blocks(self, content, start_marker, end_marker):
-        """Find all blocks between start_marker and end_marker, return count and starting line numbers."""
-        lines = content.splitlines(keepends=True)
-        joined = "".join(lines)
-        match_lines = []
-        idx = 0
-        occurrences = 0
-        while True:
-            start_idx = joined.find(start_marker, idx)
-            if start_idx == -1:
-                break
-            end_idx = joined.find(end_marker, start_idx + len(start_marker))
-            if end_idx == -1:
-                break
-            upto = joined[:start_idx]
-            line_no = upto.count("\n") + 1
-            match_lines.append(line_no)
-            idx = end_idx + len(end_marker)
-            occurrences += 1
-        return occurrences, match_lines
-
-    def _delete_blocks(self, content, start_marker, end_marker):
-        """Delete all blocks between start_marker and end_marker (inclusive)."""
-        count = 0
-        new_content = content
-        while True:
-            start_idx = new_content.find(start_marker)
-            if start_idx == -1:
-                break
-            end_idx = new_content.find(end_marker, start_idx + len(start_marker))
-            if end_idx == -1:
-                break
-            new_content = (
-                new_content[:start_idx] + new_content[end_idx + len(end_marker) :]
-            )
-            count += 1
-        return new_content, count
-
-    def _backup_file(self, path, backup_path):
-        shutil.copy2(path, backup_path)
-
-    def _write_file_content(self, path, content):
-        with open(path, "w", encoding="utf-8", errors="replace") as f:
-            f.write(content)
-
-    def _report_success(self, match_lines):
-        if match_lines:
-            lines_str = ", ".join(str(line_no) for line_no in match_lines)
-            self.report_success(
-                tr(
-                    " ✅ deleted block(s) starting at line(s): {lines_str}",
-                    lines_str=lines_str,
-                ),
-                ReportAction.CREATE,
-            )
-        else:
-            self.report_success(
-                tr(" ✅ deleted block(s) (lines unknown)"), ReportAction.CREATE
-            )

janito/plugins_backup_20250825_070018/core/filemanager/tools/find_files.py

@@ -1,143 +0,0 @@
-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.tools.tool_utils import pluralize, display_path
-from janito.dir_walk_utils import walk_dir_with_gitignore
-from janito.i18n import tr
-import fnmatch
-import os
-from janito.tools.path_utils import expand_path
-from janito.tools.loop_protection_decorator import protect_against_loops
-
-
-@register_local_tool
-class FindFilesTool(ToolBase):
-    """
-    Find files or directories in one or more directories matching a pattern. Respects .gitignore.
-
-    If a path is an existing file, it is checked against the provided pattern(s) and included in the results if it matches. This allows find_files to be used to look for a specific set of filenames in a single call, as well as searching directories.
-
-    Args:
-        paths (str): String of one or more paths (space-separated) to search in. Each path can be a directory or a file.
-        pattern (str): File pattern(s) to match. Multiple patterns can be separated by spaces. Uses Unix shell-style wildcards (fnmatch), e.g. '*.py', 'data_??.csv', '[a-z]*.txt'.
-            - If the pattern ends with '/' or '\', only matching directory names (with trailing slash) are returned, not the files within those directories. For example, pattern '*/' will return only directories at the specified depth.
-        max_depth (int, optional): Maximum directory depth to search. If None, unlimited recursion. If 0, only the top-level directory. If 1, only the root directory (matches 'find . -maxdepth 1').
-        include_gitignored (bool, optional): If True, includes files/directories ignored by .gitignore. Defaults to False.
-    Returns:
-        str: Newline-separated list of matching file paths. Example:
-            "/path/to/file1.py\n/path/to/file2.py"
-            "Warning: Empty file pattern provided. Operation skipped."
-    """
-
-    permissions = ToolPermissions(read=True)
-    tool_name = "find_files"
-
-    def _match_directories(self, root, dirs, pat):
-        dir_output = set()
-        dir_pat = pat.rstrip("/\\")
-        for d in dirs:
-            if fnmatch.fnmatch(d, dir_pat):
-                dir_output.add(os.path.join(root, d) + os.sep)
-        return dir_output
-
-    def _match_files(self, root, files, pat):
-        file_output = set()
-        for filename in fnmatch.filter(files, pat):
-            file_output.add(os.path.join(root, filename))
-        return file_output
-
-    def _match_dirs_without_slash(self, root, dirs, pat):
-        dir_output = set()
-        for d in fnmatch.filter(dirs, pat):
-            dir_output.add(os.path.join(root, d))
-        return dir_output
-
-    def _handle_path(self, directory, patterns):
-        dir_output = set()
-        filename = os.path.basename(directory)
-        for pat in patterns:
-            # Only match files, not directories, for file paths
-            if not (pat.endswith("/") or pat.endswith("\\")):
-                if fnmatch.fnmatch(filename, pat):
-                    dir_output.add(directory)
-                    break
-        return dir_output
-
-    def _handle_directory_path(
-        self, directory, patterns, max_depth, include_gitignored
-    ):
-        dir_output = set()
-        for root, dirs, files in walk_dir_with_gitignore(
-            directory,
-            max_depth=max_depth,
-            include_gitignored=include_gitignored,
-        ):
-            for pat in patterns:
-                if pat.endswith("/") or pat.endswith("\\"):
-                    dir_output.update(self._match_directories(root, dirs, pat))
-                else:
-                    dir_output.update(self._match_files(root, files, pat))
-                    dir_output.update(self._match_dirs_without_slash(root, dirs, pat))
-        return dir_output
-
-    def _report_search(self, pattern, disp_path, depth_msg):
-        self.report_action(
-            tr(
-                "🔍 Search for files '{pattern}' in '{disp_path}'{depth_msg} ...",
-                pattern=pattern,
-                disp_path=disp_path,
-                depth_msg=depth_msg,
-            ),
-            ReportAction.READ,
-        )
-
-    def _report_success(self, count):
-        self.report_success(
-            tr(
-                " ✅ {count} {file_word}",
-                count=count,
-                file_word=pluralize("file", count),
-            ),
-            ReportAction.READ,
-        )
-
-    def _format_output(self, directory, dir_output):
-        if directory.strip() == ".":
-            dir_output = {
-                p[2:] if (p.startswith("./") or p.startswith(".\\")) else p
-                for p in dir_output
-            }
-        return sorted(dir_output)
-
-    @protect_against_loops(max_calls=5, time_window=10.0, key_field="paths")
-    def run(
-        self,
-        paths: str,
-        pattern: str,
-        max_depth: int = None,
-        include_gitignored: bool = False,
-    ) -> str:
-        if not pattern:
-            self.report_warning(tr("ℹ️ Empty file pattern provided."), ReportAction.READ)
-            return tr("Warning: Empty file pattern provided. Operation skipped.")
-        patterns = pattern.split()
-        results = []
-        for directory in [expand_path(p) for p in paths.split()]:
-            disp_path = display_path(directory)
-            depth_msg = (
-                tr(" (max depth: {max_depth})", max_depth=max_depth)
-                if max_depth is not None and max_depth > 0
-                else ""
-            )
-            self._report_search(pattern, disp_path, depth_msg)
-            dir_output = set()
-            if os.path.isfile(directory):
-                dir_output = self._handle_path(directory, patterns)
-            elif os.path.isdir(directory):
-                dir_output = self._handle_directory_path(
-                    directory, patterns, max_depth, include_gitignored
-                )
-            self._report_success(len(dir_output))
-            results.extend(self._format_output(directory, dir_output))
-        result = "\n".join(results)
-        return result

janito/plugins_backup_20250825_070018/core/filemanager/tools/move_file.py

@@ -1,131 +0,0 @@
-import os
-from janito.tools.path_utils import expand_path
-import shutil
-from janito.tools.adapters.local.adapter import register_local_tool
-from janito.tools.tool_utils import display_path
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.report_events import ReportAction
-from janito.i18n import tr
-
-
-@register_local_tool
-class MoveFileTool(ToolBase):
-    """
-    Move a file or directory from src_path to dest_path.
-
-    Args:
-        src_path (str): Source file or directory path.
-        dest_path (str): Destination file or directory path.
-        overwrite (bool, optional): Whether to overwrite if the destination exists. Defaults to False.
-        backup (bool, optional): Deprecated. No backups are created anymore. This flag is ignored. Defaults to False.
-    Returns:
-        str: Status message indicating the result.
-    """
-
-    permissions = ToolPermissions(read=True, write=True)
-    tool_name = "move_file"
-
-    def run(
-        self,
-        src_path: str,
-        dest_path: str,
-        overwrite: bool = False,
-        backup: bool = False,
-    ) -> str:
-        src = expand_path(src_path)
-        dest = expand_path(dest_path)
-        original_src = src_path
-        original_dest = dest_path
-        disp_src = display_path(original_src)
-        disp_dest = display_path(original_dest)
-        backup_path = None
-
-        valid, is_src_file, is_src_dir, err_msg = self._validate_source(src, disp_src)
-        if not valid:
-            return err_msg
-
-        dest_result = self._handle_destination(dest, disp_dest, overwrite, backup)
-        if dest_result is not None:
-            backup_path, err_msg = dest_result
-            if err_msg:
-                return err_msg
-
-        try:
-            self.report_action(
-                tr(
-                    "📝 Moving from '{disp_src}' to '{disp_dest}' ...",
-                    disp_src=disp_src,
-                    disp_dest=disp_dest,
-                ),
-                ReportAction.UPDATE,
-            )
-            shutil.move(src, dest)
-            self.report_success(tr("✅ Move complete."))
-            msg = tr("✅ Move complete.")
-
-            return msg
-        except Exception as e:
-            self.report_error(tr("❌ Error moving: {error}", error=e))
-            return tr("❌ Error moving: {error}", error=e)
-
-    def _validate_source(self, src, disp_src):
-        if not os.path.exists(src):
-            self.report_error(
-                tr("❌ Source '{disp_src}' does not exist.", disp_src=disp_src)
-            )
-            return (
-                False,
-                False,
-                False,
-                tr("❌ Source '{disp_src}' does not exist.", disp_src=disp_src),
-            )
-        is_src_file = os.path.isfile(src)
-        is_src_dir = os.path.isdir(src)
-        if not (is_src_file or is_src_dir):
-            self.report_error(
-                tr(
-                    "❌ Source path '{disp_src}' is neither a file nor a directory.",
-                    disp_src=disp_src,
-                )
-            )
-            return (
-                False,
-                False,
-                False,
-                tr(
-                    "❌ Source path '{disp_src}' is neither a file nor a directory.",
-                    disp_src=disp_src,
-                ),
-            )
-        return True, is_src_file, is_src_dir, None
-
-    def _handle_destination(self, dest, disp_dest, overwrite, backup):
-        backup_path = None
-        if os.path.exists(dest):
-            if not overwrite:
-                self.report_error(
-                    tr(
-                        "❗ Destination '{disp_dest}' exists and overwrite is False.",
-                        disp_dest=disp_dest,
-                    ),
-                    ReportAction.UPDATE,
-                )
-                return None, tr(
-                    "❗ Destination '{disp_dest}' already exists and overwrite is False.",
-                    disp_dest=disp_dest,
-                )
-
-            try:
-                if os.path.isfile(dest):
-                    os.remove(dest)
-                elif os.path.isdir(dest):
-                    shutil.rmtree(dest)
-            except Exception as e:
-                self.report_error(
-                    tr("❌ Error removing destination before move: {error}", error=e),
-                    ReportAction.UPDATE,
-                )
-                return None, tr(
-                    "❌ Error removing destination before move: {error}", error=e
-                )
-        return backup_path, None

janito/plugins_backup_20250825_070018/core/filemanager/tools/read_files.py

@@ -1,58 +0,0 @@
-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.tools.tool_utils import pluralize
-from janito.i18n import tr
-from janito.tools.loop_protection_decorator import protect_against_loops
-
-
-@register_local_tool
-class ReadFilesTool(ToolBase):
-    """
-    Read all text content from multiple files.
-
-    Args:
-        paths (list[str]): List of file paths to read.
-
-    Returns:
-        str: Concatenated content of all files, each prefixed by a header with the file name. If a file cannot be read, an error message is included for that file.
-    """
-
-    permissions = ToolPermissions(read=True)
-    tool_name = "read_files"
-
-    @protect_against_loops(max_calls=5, time_window=10.0, key_field="paths")
-    def run(self, paths: list[str]) -> str:
-        from janito.tools.tool_utils import display_path
-        import os
-        from janito.tools.path_utils import expand_path
-
-        results = []
-        for path in [expand_path(p) for p in paths]:
-            disp_path = display_path(path)
-            self.report_action(
-                tr("📖 Read '{disp_path}'", disp_path=disp_path), ReportAction.READ
-            )
-            if not os.path.isfile(path):
-                self.report_warning(
-                    tr("❗ not found: {disp_path}", disp_path=disp_path)
-                )
-                results.append(f"--- File: {disp_path} (not found) ---\n")
-                continue
-            try:
-                with open(path, "r", encoding="utf-8", errors="replace") as f:
-                    content = f.read()
-                results.append(f"--- File: {disp_path} ---\n{content}\n")
-                self.report_success(tr("✅ Read {disp_path}", disp_path=disp_path))
-            except Exception as e:
-                self.report_error(
-                    tr(
-                        " ❌ Error reading {disp_path}: {error}",
-                        disp_path=disp_path,
-                        error=e,
-                    )
-                )
-                results.append(
-                    f"--- File: {disp_path} (error) ---\nError reading file: {e}\n"
-                )
-        return "\n".join(results)

janito/plugins_backup_20250825_070018/core/filemanager/tools/remove_directory.py

@@ -1,55 +0,0 @@
-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.tools.tool_utils import pluralize, display_path
-from janito.i18n import tr
-import shutil
-import os
-import zipfile
-from janito.tools.path_utils import expand_path
-
-
-@register_local_tool
-class RemoveDirectoryTool(ToolBase):
-    """
-    Remove a directory.
-
-    Args:
-        path (str): Path to the directory to remove.
-        recursive (bool, optional): If True, remove non-empty directories recursively (with backup). If False, only remove empty directories. Defaults to False.
-    Returns:
-        str: Status message indicating result. Example:
-            - "Directory removed: /path/to/dir"
-            - "Error removing directory: <error message>"
-    """
-
-    permissions = ToolPermissions(write=True)
-    tool_name = "remove_directory"
-
-    def run(self, path: str, recursive: bool = False) -> str:
-        path = expand_path(path)
-        disp_path = display_path(path)
-        self.report_action(
-            tr("🗃️ Remove directory '{disp_path}' ...", disp_path=disp_path),
-            ReportAction.DELETE,
-        )
-
-        try:
-            if recursive:
-
-                shutil.rmtree(path)
-            else:
-                os.rmdir(path)
-            self.report_success(
-                tr("✅ 1 {dir_word}", dir_word=pluralize("directory", 1)),
-                ReportAction.DELETE,
-            )
-            msg = tr("Directory removed: {disp_path}", disp_path=disp_path)
-
-            return msg
-        except Exception as e:
-            self.report_error(
-                tr(" ❌ Error removing directory: {error}", error=e),
-                ReportAction.DELETE,
-            )
-            return tr("Error removing directory: {error}", error=e)

janito/plugins_backup_20250825_070018/core/filemanager/tools/remove_file.py

@@ -1,58 +0,0 @@
-import os
-from janito.tools.path_utils import expand_path
-import shutil
-from janito.tools.adapters.local.adapter import register_local_tool
-
-from janito.tools.tool_utils import display_path
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.report_events import ReportAction
-from janito.i18n import tr
-
-
-@register_local_tool
-class RemoveFileTool(ToolBase):
-    """
-    Remove a file at the specified path.
-
-    Args:
-        path (str): Path to the file to remove.
-        backup (bool, optional): Deprecated. Backups are no longer created. Flag ignored.
-    Returns:
-        str: Status message indicating the result. Example:
-            - "			 Successfully removed the file at ..."
-            - "			 Cannot remove file: ..."
-    """
-
-    permissions = ToolPermissions(write=True)
-    tool_name = "remove_file"
-
-    def run(self, path: str, backup: bool = False) -> str:
-        path = expand_path(path)
-        disp_path = display_path(path)
-
-        # Report initial info about what is going to be removed
-        self.report_action(
-            tr("🗑️ Remove file '{disp_path}' ...", disp_path=disp_path),
-            ReportAction.DELETE,
-        )
-        if not os.path.exists(path):
-            self.report_error(tr("❌ File does not exist."), ReportAction.DELETE)
-            return tr("❌ File does not exist.")
-        if not os.path.isfile(path):
-            self.report_error(tr("❌ Path is not a file."), ReportAction.DELETE)
-            return tr("❌ Path is not a file.")
-        try:
-
-            os.remove(path)
-            self.report_success(tr("✅ File removed"), ReportAction.DELETE)
-            msg = tr(
-                "✅ Successfully removed the file at '{disp_path}'.",
-                disp_path=disp_path,
-            )
-
-            return msg
-        except Exception as e:
-            self.report_error(
-                tr("❌ Error removing file: {error}", error=e), ReportAction.DELETE
-            )
-            return tr("❌ Error removing file: {error}", error=e)