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

janito/plugins/core_loader.py

@@ -1,120 +0,0 @@
-"""
-Core plugin loader that properly handles function-based plugins.
-
-This module provides a simplified approach to load core plugins
-without the complex discovery mechanism.
-"""
-
-import importlib.util
-import sys
-from pathlib import Path
-from typing import Optional
-
-from janito.plugins.base import Plugin, PluginMetadata
-from janito.tools.function_adapter import create_function_tool
-from janito.tools.tool_base import ToolBase
-
-
-class CorePlugin(Plugin):
-    """Simple core plugin implementation."""
-    
-    def __init__(self, name: str, description: str, tools: list):
-        super().__init__()
-        self._plugin_name = name
-        self._description = description
-        self._tools = tools
-        self._tool_classes = []
-        
-    def get_metadata(self) -> PluginMetadata:
-        return PluginMetadata(
-            name=self._plugin_name,
-            version="1.0.0",
-            description=self._description,
-            author="Janito",
-            license="MIT",
-        )
-    
-    def get_tools(self) -> list:
-        return self._tool_classes
-    
-    def initialize(self):
-        """Initialize by creating tool classes."""
-        self._tool_classes = []
-        for tool_func in self._tools:
-            if callable(tool_func):
-                tool_class = create_function_tool(tool_func)
-                self._tool_classes.append(tool_class)
-
-
-def load_core_plugin(plugin_name: str) -> Optional[Plugin]:
-    """
-    Load a core plugin by name.
-    
-    Args:
-        plugin_name: Name of the plugin (e.g., 'core.filemanager')
-        
-    Returns:
-        Plugin instance if loaded successfully
-    """
-    try:
-        # Parse plugin name
-        if "." not in plugin_name:
-            return None
-            
-        parts = plugin_name.split(".")
-        if len(parts) != 2:
-            return None
-            
-        package_name, submodule_name = parts
-        
-        # Build path to plugin
-        plugin_path = Path("plugins") / package_name / submodule_name / "__init__.py"
-        if not plugin_path.exists():
-            return None
-            
-        # Load the module
-        spec = importlib.util.spec_from_file_location(plugin_name, plugin_path)
-        if spec is None or spec.loader is None:
-            return None
-            
-        module = importlib.util.module_from_spec(spec)
-        spec.loader.exec_module(module)
-        
-        # Get plugin info
-        name = getattr(module, "__plugin_name__", plugin_name)
-        description = getattr(module, "__plugin_description__", f"Core plugin: {plugin_name}")
-        tools = getattr(module, "__plugin_tools__", [])
-        
-        if not tools:
-            return None
-            
-        # Create plugin
-        plugin = CorePlugin(name, description, tools)
-        plugin.initialize()
-        return plugin
-        
-    except Exception as e:
-        print(f"Error loading core plugin {plugin_name}: {e}")
-        return None
-
-
-def get_core_plugins() -> list:
-    """Get list of all available core plugins."""
-    core_plugins = [
-        "core.filemanager",
-        "core.codeanalyzer",
-        "core.system",
-        "core.imagedisplay",
-        "dev.pythondev",
-        "dev.visualization",
-        "ui.userinterface",
-        "web.webtools",
-    ]
-    
-    available = []
-    for plugin_name in core_plugins:
-        plugin = load_core_plugin(plugin_name)
-        if plugin:
-            available.append(plugin_name)
-    
-    return available

janito/plugins/core_loader_fixed.py

@@ -1,125 +0,0 @@
-"""
-Fixed core plugin loader.
-
-This module provides a working implementation to load core plugins
-by directly using the Plugin base class properly.
-"""
-
-import importlib.util
-import sys
-from pathlib import Path
-from typing import Optional, List, Type
-
-from janito.plugins.base import Plugin, PluginMetadata
-from janito.tools.function_adapter import create_function_tool
-from janito.tools.tool_base import ToolBase
-
-
-class CorePlugin(Plugin):
-    """Working core plugin implementation."""
-    
-    def __init__(self, name: str, description: str, tools: list):
-        self._plugin_name = name
-        self._description = description
-        self._tools = tools
-        self._tool_classes = []
-        super().__init__()  # Call super after setting attributes
-        
-    def get_metadata(self) -> PluginMetadata:
-        return PluginMetadata(
-            name=self._plugin_name,
-            version="1.0.0",
-            description=self._description,
-            author="Janito",
-            license="MIT",
-        )
-    
-    def get_tools(self) -> List[Type[ToolBase]]:
-        return self._tool_classes
-    
-    def initialize(self):
-        """Initialize by creating tool classes."""
-        self._tool_classes = []
-        for tool_func in self._tools:
-            if callable(tool_func):
-                tool_class = create_function_tool(tool_func)
-                self._tool_classes.append(tool_class)
-
-
-def load_core_plugin(plugin_name: str) -> Optional[Plugin]:
-    """
-    Load a core plugin by name.
-    
-    Args:
-        plugin_name: Name of the plugin (e.g., 'core.filemanager')
-        
-    Returns:
-        Plugin instance if loaded successfully
-    """
-    try:
-        # Parse plugin name
-        if "." not in plugin_name:
-            return None
-            
-        parts = plugin_name.split(".")
-        if len(parts) != 2:
-            return None
-            
-        package_name, submodule_name = parts
-        
-        # Handle imagedisplay specially
-        if plugin_name == "core.imagedisplay":
-            # Import the actual plugin class
-            try:
-                from plugins.core.imagedisplay.plugin import ImageDisplayPlugin
-                return ImageDisplayPlugin()
-            except ImportError:
-                # If import fails, return None - don't return True
-                return None
-        
-        # Build path to plugin
-        plugin_path = Path("plugins") / package_name / submodule_name / "__init__.py"
-        if not plugin_path.exists():
-            return None
-            
-        # Load the module
-        spec = importlib.util.spec_from_file_location(plugin_name, plugin_path)
-        if spec is None or spec.loader is None:
-            return None
-            
-        module = importlib.util.module_from_spec(spec)
-        spec.loader.exec_module(module)
-        
-        # Get plugin info
-        name = getattr(module, "__plugin_name__", plugin_name)
-        description = getattr(module, "__plugin_description__", f"Core plugin: {plugin_name}")
-        tools = getattr(module, "__plugin_tools__", [])
-        
-        if not tools:
-            return None
-            
-        # Create plugin
-        plugin = CorePlugin(name, description, tools)
-        plugin.initialize()
-        return plugin
-        
-    except Exception as e:
-        print(f"Error loading core plugin {plugin_name}: {e}")
-        return None
-
-
-def get_core_plugins() -> list:
-    """Get list of all available core plugins."""
-    core_plugins = [
-        "core.filemanager",
-        "core.codeanalyzer",
-        "core.system",
-        "core.imagedisplay",
-        "dev.pythondev",
-        "dev.visualization",
-        "ui.userinterface",
-        "web.webtools",
-    ]
-    
-    # All core plugins are always available
-    return core_plugins

janito/tools/function_adapter.py

@@ -1,65 +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."""
-    
-    def __init__(self, func, tool_name: str = None, description: str = None):
-        super().__init__()
-        self._func = func
-        self.tool_name = tool_name or 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, **kwargs) -> Any:
-        """Execute the wrapped function."""
-        return self._func(**kwargs)
-    
-    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
-    """
-    
-    class DynamicFunctionTool(FunctionToolAdapter):
-        def __init__(self):
-            super().__init__(func, tool_name, description)
-    
-    return DynamicFunctionTool

janito-3.4.0.dist-info/METADATA

@@ -1,84 +0,0 @@
-Metadata-Version: 2.4
-Name: janito
-Version: 3.4.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
-Requires-Dist: janito-coder; 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