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

janito/tools/adapters/local/view_file.py

@@ -1,167 +1,167 @@
-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.tools.tool_utils import pluralize
-from janito.i18n import tr
-
-
-@register_local_tool
-class ViewFileTool(ToolBase):
-    """
-    Read lines from a file. You can specify a line range, or read the entire file by simply omitting the from_line and to_line parameters.
-
-    Args:
-        file_path (str): Path to the file to read lines from.
-        from_line (int, optional): Starting line number (1-based). Omit to start from the first line.
-        to_line (int, optional): Ending line number (1-based). Omit to read to the end of the file.
-
-    To read the full file, just provide file_path and leave from_line and to_line unset.
-
-    Returns:
-        str: File content with a header indicating the file name and line range. Example:
-            - "---\nFile: /path/to/file.py | Lines: 1-10 (of 100)\n---\n<lines...>"
-            - "---\nFile: /path/to/file.py | All lines (total: 100 (all))\n---\n<all lines...>"
-            - "Error reading file: <error message>"
-            - "❗ not found"
-    """
-
-    tool_name = "view_file"
-
-    def run(self, file_path: str, from_line: int = None, to_line: int = None) -> str:
-        import os
-        from janito.tools.tool_utils import display_path
-
-        disp_path = display_path(file_path)
-        self.report_action(
-            tr("📖 View '{disp_path}'", disp_path=disp_path),
-            ReportAction.READ,
-        )
-        try:
-            if os.path.isdir(file_path):
-                return self._list_directory(file_path, disp_path)
-            lines = self._read_file_lines(file_path)
-            selected, selected_len, total_lines = self._select_lines(
-                lines, from_line, to_line
-            )
-            self._report_success(selected_len, from_line, to_line, total_lines)
-            header = self._format_header(
-                disp_path, from_line, to_line, selected_len, total_lines
-            )
-            return header + "".join(selected)
-        except FileNotFoundError as e:
-            self.report_warning(tr("❗ not found"))
-            return f"Error reading file: {e}"
-        except Exception as e:
-            self.report_error(tr(" ❌ Error: {error}", error=e))
-            return tr("Error reading file: {error}", error=e)
-
-    def _list_directory(self, file_path, disp_path):
-        import os
-
-        try:
-            entries = os.listdir(file_path)
-            entries.sort()
-            # Suffix subdirectories with '/'
-            formatted_entries = []
-            for entry in entries:
-                full_path = os.path.join(file_path, entry)
-                if os.path.isdir(full_path):
-                    formatted_entries.append(entry + "/")
-                else:
-                    formatted_entries.append(entry)
-            header = (
-                f"--- view_file: {disp_path} [directory, {len(entries)} entries] ---\n"
-            )
-            listing = "\n".join(formatted_entries)
-            self.report_success(tr("📁 Directory ({count} items)", count=len(entries)))
-            return header + listing + "\n"
-        except Exception as e:
-            self.report_error(tr(" ❌ Error listing directory: {error}", error=e))
-            return tr("Error listing directory: {error}", error=e)
-
-    def _read_file_lines(self, file_path):
-        """Read all lines from the file."""
-        with open(file_path, "r", encoding="utf-8", errors="replace") as f:
-            return f.readlines()
-
-    def _select_lines(self, lines, from_line, to_line):
-        """Select the requested lines and return them with their count and total lines."""
-        selected = lines[
-            (from_line - 1 if from_line else 0) : (to_line if to_line else None)
-        ]
-        selected_len = len(selected)
-        total_lines = len(lines)
-        return selected, selected_len, total_lines
-
-    def _report_success(self, selected_len, from_line, to_line, total_lines):
-        """Report the success message after reading lines."""
-        if from_line and to_line:
-            requested = to_line - from_line + 1
-            at_end = to_line >= total_lines or selected_len < requested
-            if at_end:
-                self.report_success(
-                    tr(
-                        " ✅ {selected_len} {line_word} (end)",
-                        selected_len=selected_len,
-                        line_word=pluralize("line", selected_len),
-                    )
-                )
-            elif to_line < total_lines:
-                self.report_success(
-                    tr(
-                        " ✅ {selected_len} {line_word} ({remaining} to end)",
-                        selected_len=selected_len,
-                        line_word=pluralize("line", selected_len),
-                        remaining=total_lines - to_line,
-                    )
-                )
-        else:
-            self.report_success(
-                tr(
-                    " ✅ {selected_len} {line_word} (all)",
-                    selected_len=selected_len,
-                    line_word=pluralize("line", selected_len),
-                )
-            )
-
-    def _format_header(self, disp_path, from_line, to_line, selected_len, total_lines):
-        """Format the header for the output."""
-        if from_line and to_line:
-            requested = to_line - from_line + 1
-            at_end = selected_len < requested or to_line >= total_lines
-            if at_end:
-                return tr(
-                    "---\n{disp_path} {from_line}-{to_line} (end)\n---\n",
-                    disp_path=disp_path,
-                    from_line=from_line,
-                    to_line=to_line,
-                )
-            else:
-                return tr(
-                    "---\n{disp_path} {from_line}-{to_line} (of {total_lines})\n---\n",
-                    disp_path=disp_path,
-                    from_line=from_line,
-                    to_line=to_line,
-                    total_lines=total_lines,
-                )
-        elif from_line:
-            return tr(
-                "---\n{disp_path} {from_line}-END (of {total_lines})\n---\n",
-                disp_path=disp_path,
-                from_line=from_line,
-                total_lines=total_lines,
-            )
-        else:
-            return tr(
-                "---\n{disp_path} All lines (total: {total_lines} (all))\n---\n",
-                disp_path=disp_path,
-                total_lines=total_lines,
-            )
-
-    def _handle_read_error(self, e):
-        """Handle file read errors and report appropriately."""
-        if isinstance(e, FileNotFoundError):
-            self.report_error(tr("❗ not found"), ReportAction.READ)
-            return tr("❗ not found")
-        self.report_error(tr(" ❌ Error: {error}", error=e), ReportAction.READ)
-        return tr("Error reading file: {error}", error=e)
+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.tools.tool_utils import pluralize
+from janito.i18n import tr
+
+
+@register_local_tool
+class ViewFileTool(ToolBase):
+    """
+    Read lines from a file. You can specify a line range, or read the entire file by simply omitting the from_line and to_line parameters.
+
+    Args:
+        file_path (str): Path to the file to read lines from.
+        from_line (int, optional): Starting line number (1-based). Omit to start from the first line.
+        to_line (int, optional): Ending line number (1-based). Omit to read to the end of the file.
+
+    To read the full file, just provide file_path and leave from_line and to_line unset.
+
+    Returns:
+        str: File content with a header indicating the file name and line range. Example:
+            - "---\nFile: /path/to/file.py | Lines: 1-10 (of 100)\n---\n<lines...>"
+            - "---\nFile: /path/to/file.py | All lines (total: 100 (all))\n---\n<all lines...>"
+            - "Error reading file: <error message>"
+            - "❗ not found"
+    """
+
+    tool_name = "view_file"
+
+    def run(self, file_path: str, from_line: int = None, to_line: int = None) -> str:
+        import os
+        from janito.tools.tool_utils import display_path
+
+        disp_path = display_path(file_path)
+        self.report_action(
+            tr("📖 View '{disp_path}'", disp_path=disp_path),
+            ReportAction.READ,
+        )
+        try:
+            if os.path.isdir(file_path):
+                return self._list_directory(file_path, disp_path)
+            lines = self._read_file_lines(file_path)
+            selected, selected_len, total_lines = self._select_lines(
+                lines, from_line, to_line
+            )
+            self._report_success(selected_len, from_line, to_line, total_lines)
+            header = self._format_header(
+                disp_path, from_line, to_line, selected_len, total_lines
+            )
+            return header + "".join(selected)
+        except FileNotFoundError as e:
+            self.report_warning(tr("❗ not found"))
+            return f"Error reading file: {e}"
+        except Exception as e:
+            self.report_error(tr(" ❌ Error: {error}", error=e))
+            return tr("Error reading file: {error}", error=e)
+
+    def _list_directory(self, file_path, disp_path):
+        import os
+
+        try:
+            entries = os.listdir(file_path)
+            entries.sort()
+            # Suffix subdirectories with '/'
+            formatted_entries = []
+            for entry in entries:
+                full_path = os.path.join(file_path, entry)
+                if os.path.isdir(full_path):
+                    formatted_entries.append(entry + "/")
+                else:
+                    formatted_entries.append(entry)
+            header = (
+                f"--- view_file: {disp_path} [directory, {len(entries)} entries] ---\n"
+            )
+            listing = "\n".join(formatted_entries)
+            self.report_success(tr("📁 Directory ({count} items)", count=len(entries)))
+            return header + listing + "\n"
+        except Exception as e:
+            self.report_error(tr(" ❌ Error listing directory: {error}", error=e))
+            return tr("Error listing directory: {error}", error=e)
+
+    def _read_file_lines(self, file_path):
+        """Read all lines from the file."""
+        with open(file_path, "r", encoding="utf-8", errors="replace") as f:
+            return f.readlines()
+
+    def _select_lines(self, lines, from_line, to_line):
+        """Select the requested lines and return them with their count and total lines."""
+        selected = lines[
+            (from_line - 1 if from_line else 0) : (to_line if to_line else None)
+        ]
+        selected_len = len(selected)
+        total_lines = len(lines)
+        return selected, selected_len, total_lines
+
+    def _report_success(self, selected_len, from_line, to_line, total_lines):
+        """Report the success message after reading lines."""
+        if from_line and to_line:
+            requested = to_line - from_line + 1
+            at_end = to_line >= total_lines or selected_len < requested
+            if at_end:
+                self.report_success(
+                    tr(
+                        " ✅ {selected_len} {line_word} (end)",
+                        selected_len=selected_len,
+                        line_word=pluralize("line", selected_len),
+                    )
+                )
+            elif to_line < total_lines:
+                self.report_success(
+                    tr(
+                        " ✅ {selected_len} {line_word} ({remaining} to end)",
+                        selected_len=selected_len,
+                        line_word=pluralize("line", selected_len),
+                        remaining=total_lines - to_line,
+                    )
+                )
+        else:
+            self.report_success(
+                tr(
+                    " ✅ {selected_len} {line_word} (all)",
+                    selected_len=selected_len,
+                    line_word=pluralize("line", selected_len),
+                )
+            )
+
+    def _format_header(self, disp_path, from_line, to_line, selected_len, total_lines):
+        """Format the header for the output."""
+        if from_line and to_line:
+            requested = to_line - from_line + 1
+            at_end = selected_len < requested or to_line >= total_lines
+            if at_end:
+                return tr(
+                    "---\n{disp_path} {from_line}-{to_line} (end)\n---\n",
+                    disp_path=disp_path,
+                    from_line=from_line,
+                    to_line=to_line,
+                )
+            else:
+                return tr(
+                    "---\n{disp_path} {from_line}-{to_line} (of {total_lines})\n---\n",
+                    disp_path=disp_path,
+                    from_line=from_line,
+                    to_line=to_line,
+                    total_lines=total_lines,
+                )
+        elif from_line:
+            return tr(
+                "---\n{disp_path} {from_line}-END (of {total_lines})\n---\n",
+                disp_path=disp_path,
+                from_line=from_line,
+                total_lines=total_lines,
+            )
+        else:
+            return tr(
+                "---\n{disp_path} All lines (total: {total_lines} (all))\n---\n",
+                disp_path=disp_path,
+                total_lines=total_lines,
+            )
+
+    def _handle_read_error(self, e):
+        """Handle file read errors and report appropriately."""
+        if isinstance(e, FileNotFoundError):
+            self.report_error(tr("❗ not found"), ReportAction.READ)
+            return tr("❗ not found")
+        self.report_error(tr(" ❌ Error: {error}", error=e), ReportAction.READ)
+        return tr("Error reading file: {error}", error=e)

janito/tools/inspect_registry.py

@@ -1,17 +1,17 @@
-def check_tools_registry():
-    # Import and use the singleton tools adapter instance
-    from janito.tools.adapters.local import local_tools_adapter
-
-    print("Available tool names:", local_tools_adapter.list_tools())
-    print(
-        "Available tool classes:",
-        [cls.__name__ for cls in local_tools_adapter.get_tool_classes()],
-    )
-    print(
-        "Available tool instances:",
-        [tool.name for tool in local_tools_adapter.get_tools()],
-    )
-
-
-if __name__ == "__main__":
-    check_tools_registry()
+def check_tools_registry():
+    # Import and use the singleton tools adapter instance
+    from janito.tools.adapters.local import local_tools_adapter
+
+    print("Available tool names:", local_tools_adapter.list_tools())
+    print(
+        "Available tool classes:",
+        [cls.__name__ for cls in local_tools_adapter.get_tool_classes()],
+    )
+    print(
+        "Available tool instances:",
+        [tool.name for tool in local_tools_adapter.get_tools()],
+    )
+
+
+if __name__ == "__main__":
+    check_tools_registry()

janito/tools/tool_base.py

@@ -1,105 +1,105 @@
-from janito.report_events import ReportEvent, ReportSubtype, ReportAction
-from janito.event_bus.bus import event_bus as default_event_bus
-
-
-class ToolBase:
-    """
-    Base class for all tools in the janito project.
-    Extend this class to implement specific tool functionality.
-    """
-    provides_execution = False  # Indicates if the tool provides execution capability (default: False)
-
-    def __init__(self, name=None, event_bus=None):
-        self.name = name or self.__class__.__name__
-        self._event_bus = event_bus or default_event_bus
-
-    @property
-    def event_bus(self):
-        return self._event_bus
-
-    @event_bus.setter
-    def event_bus(self, bus):
-        self._event_bus = bus or default_event_bus
-
-    def report_action(self, message: str, action: ReportAction, context: dict = None):
-        """
-        Report that a tool action is starting. This should be the first reporting call for every tool action.
-        """
-        self._event_bus.publish(
-            ReportEvent(
-                subtype=ReportSubtype.ACTION_INFO,
-                message="  " + message,
-                action=action,
-                tool=self.name,
-                context=context,
-            )
-        )
-
-    def report_info(self, message: str, context: dict = None):
-        self._event_bus.publish(
-            ReportEvent(
-                subtype=ReportSubtype.ACTION_INFO,
-                message=message,
-                action=None,
-                tool=self.name,
-                context=context,
-            )
-        )
-
-    def report_error(self, message: str, context: dict = None):
-        self._event_bus.publish(
-            ReportEvent(
-                subtype=ReportSubtype.ERROR,
-                message=message,
-                action=None,
-                tool=self.name,
-                context=context,
-            )
-        )
-
-    def report_success(self, message: str, context: dict = None):
-        self._event_bus.publish(
-            ReportEvent(
-                subtype=ReportSubtype.SUCCESS,
-                message=message,
-                action=None,
-                tool=self.name,
-                context=context,
-            )
-        )
-
-    def report_warning(self, message: str, context: dict = None):
-        self._event_bus.publish(
-            ReportEvent(
-                subtype=ReportSubtype.WARNING,
-                message=message,
-                action=None,
-                tool=self.name,
-                context=context,
-            )
-        )
-
-    def report_stdout(self, message: str, context: dict = None):
-        self._event_bus.publish(
-            ReportEvent(
-                subtype=ReportSubtype.STDOUT,
-                message=message,
-                action=None,
-                tool=self.name,
-                context=context,
-            )
-        )
-
-    def report_stderr(self, message: str, context: dict = None):
-        self._event_bus.publish(
-            ReportEvent(
-                subtype=ReportSubtype.STDERR,
-                message=message,
-                action=None,
-                tool=self.name,
-                context=context,
-            )
-        )
-
-    def run(self, *args, **kwargs):
-        raise NotImplementedError("Subclasses must implement the run method.")
+from janito.report_events import ReportEvent, ReportSubtype, ReportAction
+from janito.event_bus.bus import event_bus as default_event_bus
+
+
+class ToolBase:
+    """
+    Base class for all tools in the janito project.
+    Extend this class to implement specific tool functionality.
+    """
+    provides_execution = False  # Indicates if the tool provides execution capability (default: False)
+
+    def __init__(self, name=None, event_bus=None):
+        self.name = name or self.__class__.__name__
+        self._event_bus = event_bus or default_event_bus
+
+    @property
+    def event_bus(self):
+        return self._event_bus
+
+    @event_bus.setter
+    def event_bus(self, bus):
+        self._event_bus = bus or default_event_bus
+
+    def report_action(self, message: str, action: ReportAction, context: dict = None):
+        """
+        Report that a tool action is starting. This should be the first reporting call for every tool action.
+        """
+        self._event_bus.publish(
+            ReportEvent(
+                subtype=ReportSubtype.ACTION_INFO,
+                message="  " + message,
+                action=action,
+                tool=self.name,
+                context=context,
+            )
+        )
+
+    def report_info(self, message: str, context: dict = None):
+        self._event_bus.publish(
+            ReportEvent(
+                subtype=ReportSubtype.ACTION_INFO,
+                message=message,
+                action=None,
+                tool=self.name,
+                context=context,
+            )
+        )
+
+    def report_error(self, message: str, context: dict = None):
+        self._event_bus.publish(
+            ReportEvent(
+                subtype=ReportSubtype.ERROR,
+                message=message,
+                action=None,
+                tool=self.name,
+                context=context,
+            )
+        )
+
+    def report_success(self, message: str, context: dict = None):
+        self._event_bus.publish(
+            ReportEvent(
+                subtype=ReportSubtype.SUCCESS,
+                message=message,
+                action=None,
+                tool=self.name,
+                context=context,
+            )
+        )
+
+    def report_warning(self, message: str, context: dict = None):
+        self._event_bus.publish(
+            ReportEvent(
+                subtype=ReportSubtype.WARNING,
+                message=message,
+                action=None,
+                tool=self.name,
+                context=context,
+            )
+        )
+
+    def report_stdout(self, message: str, context: dict = None):
+        self._event_bus.publish(
+            ReportEvent(
+                subtype=ReportSubtype.STDOUT,
+                message=message,
+                action=None,
+                tool=self.name,
+                context=context,
+            )
+        )
+
+    def report_stderr(self, message: str, context: dict = None):
+        self._event_bus.publish(
+            ReportEvent(
+                subtype=ReportSubtype.STDERR,
+                message=message,
+                action=None,
+                tool=self.name,
+                context=context,
+            )
+        )
+
+    def run(self, *args, **kwargs):
+        raise NotImplementedError("Subclasses must implement the run method.")