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

janito/plugins_backup_20250825_070018/web/webtools/tools/open_url.py

@@ -0,0 +1,37 @@
+import webbrowser
+from janito.tools.adapters.local.adapter import register_local_tool
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from janito.report_events import ReportAction
+from janito.i18n import tr
+from janito.tools.loop_protection_decorator import protect_against_loops
+
+
+@register_local_tool
+class OpenUrlTool(ToolBase):
+    """
+    Open the supplied URL or local file in the default web browser.
+
+    Args:
+        url (str): The URL or local file path (as a file:// URL) to open. Supports both web URLs (http, https) and local files (file://).
+    Returns:
+        str: Status message indicating the result.
+    """
+
+    permissions = ToolPermissions(read=True)
+    tool_name = "open_url"
+
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="url")
+    def run(self, url: str) -> str:
+        if not url.strip():
+            self.report_warning(tr("ℹ️ Empty URL provided."))
+            return tr("Warning: Empty URL provided. Operation skipped.")
+        self.report_action(tr("🌐 Opening URL '{url}' ...", url=url), ReportAction.READ)
+        try:
+            webbrowser.open(url)
+        except Exception as err:
+            self.report_error(
+                tr("❗ Error opening URL: {url}: {err}", url=url, err=str(err))
+            )
+            return tr("Warning: Error opening URL: {url}: {err}", url=url, err=str(err))
+        self.report_success(tr("✅ URL opened in browser: {url}", url=url))
+        return tr("URL opened in browser: {url}", url=url)

janito/tools/base.py

@@ -1,5 +1,35 @@
 class BaseTool:
-    """Base class for all tools."""
+    """
+    Base class for all tools.
+    
+    Parameters:
+        path (str): Target file path for file operations
+        content (str): File content to write or process
+        overwrite (bool): Whether to overwrite existing files (default: False)
+        sources (str): Source file(s) to copy from
+        target (str): Destination path for copy operations
+        recursive (bool): Whether to process directories recursively
+        from_line (int): Starting line number for file reading
+        to_line (int): Ending line number for file reading
+        search_text (str): Text to search for in files
+        replacement_text (str): Text to replace search matches with
+        use_regex (bool): Whether to treat search as regex pattern
+        case_sensitive (bool): Whether search should be case sensitive
+        max_depth (int): Maximum directory depth to search
+        include_gitignored (bool): Whether to include .gitignored files
+        timeout (int): Timeout in seconds for operations
+        require_confirmation (bool): Whether to require user confirmation
+        data (dict): Chart data for visualization tools
+        title (str): Chart title
+        width (int): Chart width in pixels
+        height (int): Chart height in pixels
+        query (str): Search query for text search
+        paths (str): Directory or file paths to search in
+        src_path (str): Source path for move operations
+        dest_path (str): Destination path for move operations
+        code (str): Python code to execute
+        pattern (str): File pattern to match (e.g., '*.py')
+    """
 
     tool_name: str = ""
 

janito/tools/cli_initializer.py

@@ -17,7 +17,7 @@ def initialize_cli_tools():
     """Initialize tools for CLI usage, avoiding circular imports."""
     try:
         from janito.tools.adapters.local.adapter import LocalToolsAdapter
-        from janito.plugin_system.core_loader_fixed import load_core_plugin
+        from janito.plugins.core_loader import load_core_plugin
         from janito.tools.permissions import set_global_allowed_permissions
         from janito.tools.tool_base import ToolPermissions
 

janito/tools/function_adapter.py

@@ -10,7 +10,41 @@ from janito.tools.tool_base import ToolBase, ToolPermissions
 
 
 class FunctionToolAdapter(ToolBase):
-    """Adapter that wraps a function into a ToolBase class."""
+    """
+    Adapter that wraps a function into a ToolBase class.
+    
+    This adapter provides a unified interface for function-based tools by wrapping
+    individual functions with the ToolBase protocol. It handles parameter mapping
+    and validation automatically.
+    
+    Parameters:
+        path (str): Target file path for file operations
+        content (str): File content to write or process
+        overwrite (bool): Whether to overwrite existing files (default: False)
+        sources (str): Source file(s) to copy from
+        target (str): Destination path for copy operations
+        recursive (bool): Whether to process directories recursively
+        from_line (int): Starting line number for file reading
+        to_line (int): Ending line number for file reading
+        search_text (str): Text to search for in files
+        replacement_text (str): Text to replace search matches with
+        use_regex (bool): Whether to treat search as regex pattern
+        case_sensitive (bool): Whether search should be case sensitive
+        max_depth (int): Maximum directory depth to search
+        include_gitignored (bool): Whether to include .gitignored files
+        timeout (int): Timeout in seconds for operations
+        require_confirmation (bool): Whether to require user confirmation
+        data (dict): Chart data for visualization tools
+        title (str): Chart title
+        width (int): Chart width in pixels
+        height (int): Chart height in pixels
+        query (str): Search query for text search
+        paths (str): Directory or file paths to search in
+        src_path (str): Source path for move operations
+        dest_path (str): Destination path for move operations
+        code (str): Python code to execute
+        pattern (str): File pattern to match (e.g., '*.py')
+    """
 
     def __init__(self, func, tool_name: str = None, description: str = None):
         super().__init__()

janito/tools/initialize.py

@@ -9,7 +9,7 @@ import sys
 from pathlib import Path
 from typing import List, Optional
 
-from janito.plugin_system.core_loader_fixed import load_core_plugin
+from janito.plugins.core_loader import load_core_plugin
 from janito.tools.adapters.local.adapter import LocalToolsAdapter
 
 

janito/tools/tool_base.py

@@ -1,114 +1,142 @@
-from janito.report_events import ReportEvent, ReportSubtype, ReportAction
-from janito.event_bus.bus import event_bus as default_event_bus
-
-
-from collections import namedtuple
-
-
-class ToolPermissions(namedtuple("ToolPermissions", ["read", "write", "execute"])):
-    __slots__ = ()
-
-    def __new__(cls, read=False, write=False, execute=False):
-        return super().__new__(cls, read, write, execute)
-
-    def __repr__(self):
-        return f"ToolPermissions(read={self.read}, write={self.write}, execute={self.execute})"
-
-
-class ToolBase:
-    """
-    Base class for all tools in the janito project.
-    Extend this class to implement specific tool functionality.
-    """
-
-    permissions: "ToolPermissions" = None  # Required: must be set by subclasses
-
-    def __init__(self, name=None, event_bus=None):
-        if self.permissions is None or not isinstance(
-            self.permissions, ToolPermissions
-        ):
-            raise ValueError(
-                f"Tool '{self.__class__.__name__}' must define a 'permissions' attribute of type ToolPermissions."
-            )
-        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_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
+
+
+from collections import namedtuple
+
+
+class ToolPermissions(namedtuple("ToolPermissions", ["read", "write", "execute"])):
+    __slots__ = ()
+
+    def __new__(cls, read=False, write=False, execute=False):
+        return super().__new__(cls, read, write, execute)
+
+    def __repr__(self):
+        return f"ToolPermissions(read={self.read}, write={self.write}, execute={self.execute})"
+
+
+class ToolBase:
+    """
+    Base class for all tools in the janito project.
+    Extend this class to implement specific tool functionality.
+    
+    Parameters:
+        path (str): Target file path for file operations
+        content (str): File content to write or process
+        overwrite (bool): Whether to overwrite existing files (default: False)
+        sources (str): Source file(s) to copy from
+        target (str): Destination path for copy operations
+        recursive (bool): Whether to process directories recursively
+        from_line (int): Starting line number for file reading
+        to_line (int): Ending line number for file reading
+        search_text (str): Text to search for in files
+        replacement_text (str): Text to replace search matches with
+        use_regex (bool): Whether to treat search as regex pattern
+        case_sensitive (bool): Whether search should be case sensitive
+        max_depth (int): Maximum directory depth to search
+        include_gitignored (bool): Whether to include .gitignored files
+        timeout (int): Timeout in seconds for operations
+        require_confirmation (bool): Whether to require user confirmation
+        data (dict): Chart data for visualization tools
+        title (str): Chart title
+        width (int): Chart width in pixels
+        height (int): Chart height in pixels
+        query (str): Search query for text search
+        paths (str): Directory or file paths to search in
+        src_path (str): Source path for move operations
+        dest_path (str): Destination path for move operations
+        code (str): Python code to execute
+        pattern (str): File pattern to match (e.g., '*.py')
+    """
+
+    permissions: "ToolPermissions" = None  # Required: must be set by subclasses
+
+    def __init__(self, name=None, event_bus=None):
+        if self.permissions is None or not isinstance(
+            self.permissions, ToolPermissions
+        ):
+            raise ValueError(
+                f"Tool '{self.__class__.__name__}' must define a 'permissions' attribute of type ToolPermissions."
+            )
+        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_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.")

janito/tools/tools_schema.py

@@ -7,6 +7,8 @@ class ToolSchemaBase:
     def parse_param_section(self, lines, param_section_headers):
         param_descs = {}
         in_params = False
+        current_param = None
+        
         for line in lines:
             stripped_line = line.strip()
             if any(
@@ -16,17 +18,21 @@ class ToolSchemaBase:
                 in_params = True
                 continue
             if in_params:
+                # Check for parameter definition: "param_name (type): description"
                 m = re.match(
-                    r"([a-zA-Z_][a-zA-Z0-9_]*)\s*(?:\(([^)]+)\))?\s*[:\-]?\s*(.+)",
+                    r"([a-zA-Z_][a-zA-Z0-9_]*)\s*(?:\([^)]+\))?\s*:\s*(.+)",
                     stripped_line,
                 )
                 if m:
-                    param, _, desc = m.groups()
+                    param, desc = m.groups()
                     param_descs[param] = desc.strip()
-                elif stripped_line and stripped_line[0] != "-":
-                    if param_descs:
-                        last = list(param_descs)[-1]
-                        param_descs[last] += " " + stripped_line
+                    current_param = param
+                elif current_param and stripped_line and not (
+                    stripped_line.lower().startswith("returns:") or 
+                    stripped_line.lower() == "returns"
+                ):
+                    # Continuation of current parameter description
+                    param_descs[current_param] += " " + stripped_line.strip()
             if (
                 stripped_line.lower().startswith("returns:")
                 or stripped_line.lower() == "returns"

{janito-3.1.0.dist-info → janito-3.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 3.1.0
+Version: 3.3.0
 Summary: A new Python package called janito.
 Author-email: João Pinto <janito@ikignosis.org>
 Project-URL: Homepage, https://github.com/ikignosis/janito