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

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

@@ -1,37 +0,0 @@
-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/function_adapter.py

@@ -1,176 +0,0 @@
-"""
-Function-to-Tool adapter for core plugins.
-
-This module provides a way to wrap function-based tools into proper ToolBase classes.
-"""
-
-import inspect
-from typing import Any, Dict, List, Optional, get_type_hints
-from janito.tools.tool_base import ToolBase, ToolPermissions
-
-
-class FunctionToolAdapter(ToolBase):
-    """
-    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__()
-        self._func = func
-        self.tool_name = tool_name or getattr(func, "tool_name", func.__name__)
-        self._description = description or func.__doc__ or f"Tool: {self.tool_name}"
-        self.permissions = ToolPermissions(read=True, write=True, execute=True)
-
-    def run(
-        self,
-        path: str = None,
-        content: str = None,
-        overwrite: bool = None,
-        sources: str = None,
-        target: str = None,
-        recursive: bool = None,
-        from_line: int = None,
-        to_line: int = None,
-        search_text: str = None,
-        replacement_text: str = None,
-        use_regex: bool = None,
-        case_sensitive: bool = None,
-        max_depth: int = None,
-        include_gitignored: bool = None,
-        timeout: int = None,
-        require_confirmation: bool = None,
-        data: dict = None,
-        title: str = None,
-        width: int = None,
-        height: int = None,
-        query: str = None,
-        paths: str = None,
-        src_path: str = None,
-        dest_path: str = None,
-        code: str = None,
-        pattern: str = None,
-    ) -> str:
-        """Execute the wrapped function."""
-        # Build kwargs from non-None parameters
-        import inspect
-
-        sig = inspect.signature(self._func)
-        filtered_kwargs = {}
-
-        # Map parameter names to their actual values
-        param_map = {
-            "path": path,
-            "content": content,
-            "overwrite": overwrite,
-            "sources": sources,
-            "target": target,
-            "recursive": recursive,
-            "from_line": from_line,
-            "to_line": to_line,
-            "search_text": search_text,
-            "replacement_text": replacement_text,
-            "use_regex": use_regex,
-            "case_sensitive": case_sensitive,
-            "max_depth": max_depth,
-            "include_gitignored": include_gitignored,
-            "timeout": timeout,
-            "require_confirmation": require_confirmation,
-            "data": data,
-            "title": title,
-            "width": width,
-            "height": height,
-            "query": query,
-            "paths": paths,
-            "src_path": src_path,
-            "dest_path": dest_path,
-            "code": code,
-            "pattern": pattern,
-        }
-
-        # Only include parameters that exist in the function signature
-        for name, param in sig.parameters.items():
-            if name in param_map and param_map[name] is not None:
-                filtered_kwargs[name] = param_map[name]
-
-        result = self._func(**filtered_kwargs)
-        return str(result) if result is not None else ""
-
-    def get_signature(self) -> Dict[str, Any]:
-        """Get function signature for documentation."""
-        sig = inspect.signature(self._func)
-        type_hints = get_type_hints(self._func)
-
-        params = {}
-        for name, param in sig.parameters.items():
-            param_info = {
-                "type": str(type_hints.get(name, Any)),
-                "default": (
-                    param.default if param.default != inspect.Parameter.empty else None
-                ),
-                "required": param.default == inspect.Parameter.empty,
-            }
-            params[name] = param_info
-
-        return {
-            "name": self.tool_name,
-            "description": self._description,
-            "parameters": params,
-            "return_type": str(type_hints.get("return", Any)),
-        }
-
-
-def create_function_tool(func, tool_name: str = None, description: str = None) -> type:
-    """
-    Create a ToolBase class from a function.
-
-    Args:
-        func: The function to wrap
-        tool_name: Optional custom tool name
-        description: Optional custom description
-
-    Returns:
-        A ToolBase subclass that wraps the function
-    """
-    # Resolve tool_name in outer scope
-    resolved_tool_name = tool_name or getattr(func, "tool_name", func.__name__)
-
-    class DynamicFunctionTool(FunctionToolAdapter):
-        permissions = ToolPermissions(read=True, write=True, execute=True)
-        tool_name = resolved_tool_name
-
-        def __init__(self):
-            super().__init__(func, DynamicFunctionTool.tool_name, description)
-
-    return DynamicFunctionTool

janito-3.3.0.dist-info/METADATA

@@ -1,83 +0,0 @@
-Metadata-Version: 2.4
-Name: janito
-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
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: attrs==25.3.0
-Requires-Dist: rich==14.0.0
-Requires-Dist: pathspec==0.12.1
-Requires-Dist: setuptools>=61.0
-Requires-Dist: pyyaml>=6.0
-Requires-Dist: jinja2>=3.0.0
-Requires-Dist: prompt_toolkit>=3.0.51
-Requires-Dist: lxml>=5.4.0
-Requires-Dist: requests>=2.32.4
-Requires-Dist: bs4>=0.0.2
-Requires-Dist: questionary>=2.0.1
-Requires-Dist: openai>=1.68.0
-Requires-Dist: Pillow>=10.0.0
-Provides-Extra: dev
-Requires-Dist: pytest; extra == "dev"
-Requires-Dist: pre-commit; extra == "dev"
-Requires-Dist: ruff==0.11.9; extra == "dev"
-Requires-Dist: detect-secrets==1.4.0; extra == "dev"
-Requires-Dist: codespell==2.4.1; extra == "dev"
-Requires-Dist: black; extra == "dev"
-Requires-Dist: questionary>=2.0.1; extra == "dev"
-Requires-Dist: setuptools_scm>=8.0; extra == "dev"
-Provides-Extra: coder
-Dynamic: license-file
-
-# nctl
-
-```bash
-$ nctl --help
-Usage: nctl <command>
-
-Interact with Nine API resources. See https://docs.nineapis.ch for the full API docs.
-
-Run "nctl <command> --help" for more information on a command.
-```
-
-## Setup
-
-```bash
-# If you have go already installed
-go install github.com/ninech/nctl@latest
-
-# Homebrew
-brew install ninech/taps/nctl
-
-# Debian/Ubuntu
-echo "deb [trusted=yes] https://repo.nine.ch/deb/ /" | sudo tee /etc/apt/sources.list.d/repo.nine.ch.list
-sudo apt-get update
-sudo apt-get install nctl
-
-# Fedora/RHEL
-cat <<EOF > /etc/yum.repos.d/repo.nine.ch.repo
-[repo.nine.ch]
-name=Nine Repo
-baseurl=https://repo.nine.ch/yum/
-enabled=1
-gpgcheck=0
-EOF
-dnf install nctl
-
-# Arch
-# Install yay: https://github.com/Jguer/yay#binary
-yay --version
-yay -S nctl-bin
-```
-
-For Windows users, nctl is also built for arm64 and amd64. You can download the
-latest exe file from the [releases](https://github.com/ninech/nctl/releases) and
-install it.
-
-## Getting started
-
-* login to the API using `nctl auth login`
-* run `nctl --help` to get a list of all available commands