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

janito/tools/adapters/local/create_file.py

@@ -1,82 +1,82 @@
-import os
-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
-from janito.report_events import ReportAction
-from janito.i18n import tr
-
-
-from janito.tools.adapters.local.validate_file_syntax.core import validate_file_syntax
-
-
-@register_local_tool
-class CreateFileTool(ToolBase):
-    """
-    Create a new file with the given content.
-
-    Args:
-        file_path (str): Path to the file to create.
-        content (str): Content to write to the file.
-        overwrite (bool, optional): Overwrite existing file if True. Default: False. Recommended only after reading the file to be overwritten.
-    Returns:
-        str: Status message indicating the result. Example:
-            - "✅ Successfully created the file at ..."
-
-    Note: Syntax validation is automatically performed after this operation.
-    """
-
-    tool_name = "create_file"
-
-    def run(self, file_path: str, content: str, overwrite: bool = False) -> str:
-        expanded_file_path = file_path  # Using file_path as is
-        disp_path = display_path(expanded_file_path)
-        file_path = expanded_file_path
-        if os.path.exists(file_path) and not overwrite:
-            try:
-                with open(file_path, "r", encoding="utf-8", errors="replace") as f:
-                    existing_content = f.read()
-            except Exception as e:
-                existing_content = f"[Error reading file: {e}]"
-            return tr(
-                "❗ Cannot create file: file already exists at '{disp_path}'.\n--- Current file content ---\n{existing_content}",
-                disp_path=disp_path,
-                existing_content=existing_content,
-            )
-        # Determine if we are overwriting an existing file
-        is_overwrite = os.path.exists(file_path) and overwrite
-        if is_overwrite:
-            # Overwrite branch: log only overwrite warning (no create message)
-            self.report_action(
-                tr("⚠️ Overwriting file '{disp_path}'", disp_path=disp_path),
-                ReportAction.CREATE,
-            )
-        dir_name = os.path.dirname(file_path)
-        if dir_name:
-            os.makedirs(dir_name, exist_ok=True)
-        if not is_overwrite:
-            # Create branch: log file creation message
-            self.report_action(
-                tr("📝 Create file '{disp_path}' ...", disp_path=disp_path),
-                ReportAction.CREATE,
-            )
-        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), ReportAction.CREATE
-        )
-        # Perform syntax validation and append result
-        validation_result = validate_file_syntax(file_path)
-        if is_overwrite:
-            # Overwrite branch: return minimal overwrite info to user
-            return (
-                tr("✅ {new_lines} lines", new_lines=new_lines)
-                + f"\n{validation_result}"
-            )
-        else:
-            # Create branch: return detailed create success to user
-            return (
-                tr("✅ Created file {new_lines} lines.", new_lines=new_lines)
-                + f"\n{validation_result}"
-            )
+import os
+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
+from janito.report_events import ReportAction
+from janito.i18n import tr
+
+
+from janito.tools.adapters.local.validate_file_syntax.core import validate_file_syntax
+
+
+@register_local_tool
+class CreateFileTool(ToolBase):
+    """
+    Create a new file with the given content.
+
+    Args:
+        file_path (str): Path to the file to create.
+        content (str): Content to write to the file.
+        overwrite (bool, optional): Overwrite existing file if True. Default: False. Recommended only after reading the file to be overwritten.
+    Returns:
+        str: Status message indicating the result. Example:
+            - "✅ Successfully created the file at ..."
+
+    Note: Syntax validation is automatically performed after this operation.
+    """
+
+    tool_name = "create_file"
+
+    def run(self, file_path: str, content: str, overwrite: bool = False) -> str:
+        expanded_file_path = file_path  # Using file_path as is
+        disp_path = display_path(expanded_file_path)
+        file_path = expanded_file_path
+        if os.path.exists(file_path) and not overwrite:
+            try:
+                with open(file_path, "r", encoding="utf-8", errors="replace") as f:
+                    existing_content = f.read()
+            except Exception as e:
+                existing_content = f"[Error reading file: {e}]"
+            return tr(
+                "❗ Cannot create file: file already exists at '{disp_path}'.\n--- Current file content ---\n{existing_content}",
+                disp_path=disp_path,
+                existing_content=existing_content,
+            )
+        # Determine if we are overwriting an existing file
+        is_overwrite = os.path.exists(file_path) and overwrite
+        if is_overwrite:
+            # Overwrite branch: log only overwrite warning (no create message)
+            self.report_action(
+                tr("⚠️ Overwriting file '{disp_path}'", disp_path=disp_path),
+                ReportAction.CREATE,
+            )
+        dir_name = os.path.dirname(file_path)
+        if dir_name:
+            os.makedirs(dir_name, exist_ok=True)
+        if not is_overwrite:
+            # Create branch: log file creation message
+            self.report_action(
+                tr("📝 Create file '{disp_path}' ...", disp_path=disp_path),
+                ReportAction.CREATE,
+            )
+        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), ReportAction.CREATE
+        )
+        # Perform syntax validation and append result
+        validation_result = validate_file_syntax(file_path)
+        if is_overwrite:
+            # Overwrite branch: return minimal overwrite info to user
+            return (
+                tr("✅ {new_lines} lines", new_lines=new_lines)
+                + f"\n{validation_result}"
+            )
+        else:
+            # Create branch: return detailed create success to user
+            return (
+                tr("✅ Created file {new_lines} lines.", new_lines=new_lines)
+                + f"\n{validation_result}"
+            )

janito/tools/adapters/local/delete_text_in_file.py

@@ -15,7 +15,7 @@ class DeleteTextInFileTool(ToolBase):
         file_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): If True, create a backup (.bak) before deleting. Defaults to False.
+
     Returns:
         str: Status message indicating the result.
     """
@@ -52,9 +52,7 @@ class DeleteTextInFileTool(ToolBase):
                     "No blocks found between markers in {file_path}.",
                     file_path=file_path,
                 )
-            backup_path = file_path + ".bak"
-            if backup:
-                self._backup_file(file_path, backup_path)
+
             new_content, deleted_blocks = self._delete_blocks(
                 content, start_marker, end_marker
             )
@@ -62,10 +60,9 @@ class DeleteTextInFileTool(ToolBase):
             validation_result = validate_file_syntax(file_path)
             self._report_success(match_lines)
             return tr(
-                "Deleted {count} block(s) between markers in {file_path}. (backup at {backup_path})",
+                "Deleted {count} block(s) between markers in {file_path}. ",
                 count=deleted_blocks,
-                file_path=file_path,
-                backup_path=backup_path if backup else "N/A",
+                file_path=file_path
             ) + (f"\n{validation_result}" if validation_result else "")
         except Exception as e:
             self.report_error(tr(" ❌ Error: {error}", error=e), ReportAction.REPLACE)

janito/tools/adapters/local/fetch_url.py

@@ -1,97 +1,97 @@
-import requests
-from bs4 import BeautifulSoup
-from janito.tools.adapters.local.adapter import register_local_tool
-from janito.tools.tool_base import ToolBase
-from janito.report_events import ReportAction
-from janito.i18n import tr
-from janito.tools.tool_utils import pluralize
-
-
-@register_local_tool
-class FetchUrlTool(ToolBase):
-    """
-    Fetch the content of a web page and extract its text.
-
-    Args:
-        url (str): The URL of the web page to fetch.
-        search_strings (list[str], optional): Strings to search for in the page content.
-    Returns:
-        str: Extracted text content from the web page, or a warning message. Example:
-            - "<main text content...>"
-            - "No lines found for the provided search strings."
-            - "Warning: Empty URL provided. Operation skipped."
-    """
-
-    tool_name = "fetch_url"
-
-    def run(self, url: str, search_strings: list[str] = None) -> str:
-        if not url.strip():
-            self.report_warning(tr("ℹ️ Empty URL provided."), ReportAction.READ)
-            return tr("Warning: Empty URL provided. Operation skipped.")
-        self.report_action(tr("🌐 Fetch URL '{url}' ...", url=url), ReportAction.READ)
-        try:
-            response = requests.get(url, timeout=10)
-            response.raise_for_status()
-        except requests.exceptions.HTTPError as http_err:
-            status_code = http_err.response.status_code if http_err.response else None
-            if status_code and 400 <= status_code < 500:
-                self.report_error(
-                    tr(
-                        "❗ HTTP {status_code} error for URL: {url}",
-                        status_code=status_code,
-                        url=url,
-                    ),
-                    ReportAction.READ,
-                )
-                return tr(
-                    "Warning: HTTP {status_code} error for URL: {url}",
-                    status_code=status_code,
-                    url=url,
-                )
-            else:
-                self.report_error(
-                    tr(
-                        "❗ HTTP error for URL: {url}: {err}",
-                        url=url,
-                        err=str(http_err),
-                    ),
-                    ReportAction.READ,
-                )
-                return tr(
-                    "Warning: HTTP error for URL: {url}: {err}",
-                    url=url,
-                    err=str(http_err),
-                )
-        except Exception as err:
-            self.report_error(
-                tr("❗ Error fetching URL: {url}: {err}", url=url, err=str(err)),
-                ReportAction.READ,
-            )
-            return tr(
-                "Warning: Error fetching URL: {url}: {err}", url=url, err=str(err)
-            )
-        soup = BeautifulSoup(response.text, "html.parser")
-        text = soup.get_text(separator="\n")
-        if search_strings:
-            filtered = []
-            for s in search_strings:
-                idx = text.find(s)
-                if idx != -1:
-                    start = max(0, idx - 200)
-                    end = min(len(text), idx + len(s) + 200)
-                    snippet = text[start:end]
-                    filtered.append(snippet)
-            if filtered:
-                text = "\n...\n".join(filtered)
-            else:
-                text = tr("No lines found for the provided search strings.")
-        num_lines = len(text.splitlines())
-        self.report_success(
-            tr(
-                "✅ {num_lines} {line_word}",
-                num_lines=num_lines,
-                line_word=pluralize("line", num_lines),
-            ),
-            ReportAction.READ,
-        )
-        return text
+import requests
+from bs4 import BeautifulSoup
+from janito.tools.adapters.local.adapter import register_local_tool
+from janito.tools.tool_base import ToolBase
+from janito.report_events import ReportAction
+from janito.i18n import tr
+from janito.tools.tool_utils import pluralize
+
+
+@register_local_tool
+class FetchUrlTool(ToolBase):
+    """
+    Fetch the content of a web page and extract its text.
+
+    Args:
+        url (str): The URL of the web page to fetch.
+        search_strings (list[str], optional): Strings to search for in the page content.
+    Returns:
+        str: Extracted text content from the web page, or a warning message. Example:
+            - "<main text content...>"
+            - "No lines found for the provided search strings."
+            - "Warning: Empty URL provided. Operation skipped."
+    """
+
+    tool_name = "fetch_url"
+
+    def run(self, url: str, search_strings: list[str] = None) -> str:
+        if not url.strip():
+            self.report_warning(tr("ℹ️ Empty URL provided."), ReportAction.READ)
+            return tr("Warning: Empty URL provided. Operation skipped.")
+        self.report_action(tr("🌐 Fetch URL '{url}' ...", url=url), ReportAction.READ)
+        try:
+            response = requests.get(url, timeout=10)
+            response.raise_for_status()
+        except requests.exceptions.HTTPError as http_err:
+            status_code = http_err.response.status_code if http_err.response else None
+            if status_code and 400 <= status_code < 500:
+                self.report_error(
+                    tr(
+                        "❗ HTTP {status_code} error for URL: {url}",
+                        status_code=status_code,
+                        url=url,
+                    ),
+                    ReportAction.READ,
+                )
+                return tr(
+                    "Warning: HTTP {status_code} error for URL: {url}",
+                    status_code=status_code,
+                    url=url,
+                )
+            else:
+                self.report_error(
+                    tr(
+                        "❗ HTTP error for URL: {url}: {err}",
+                        url=url,
+                        err=str(http_err),
+                    ),
+                    ReportAction.READ,
+                )
+                return tr(
+                    "Warning: HTTP error for URL: {url}: {err}",
+                    url=url,
+                    err=str(http_err),
+                )
+        except Exception as err:
+            self.report_error(
+                tr("❗ Error fetching URL: {url}: {err}", url=url, err=str(err)),
+                ReportAction.READ,
+            )
+            return tr(
+                "Warning: Error fetching URL: {url}: {err}", url=url, err=str(err)
+            )
+        soup = BeautifulSoup(response.text, "html.parser")
+        text = soup.get_text(separator="\n")
+        if search_strings:
+            filtered = []
+            for s in search_strings:
+                idx = text.find(s)
+                if idx != -1:
+                    start = max(0, idx - 200)
+                    end = min(len(text), idx + len(s) + 200)
+                    snippet = text[start:end]
+                    filtered.append(snippet)
+            if filtered:
+                text = "\n...\n".join(filtered)
+            else:
+                text = tr("No lines found for the provided search strings.")
+        num_lines = len(text.splitlines())
+        self.report_success(
+            tr(
+                "✅ {num_lines} {line_word}",
+                num_lines=num_lines,
+                line_word=pluralize("line", num_lines),
+            ),
+            ReportAction.READ,
+        )
+        return text