janito 3.6.1__py3-none-any.whl → 3.7.0__py3-none-any.whl

janito/plugins/ui/userinterface/tools/ask_user.py

@@ -1,110 +0,0 @@
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.tools.adapters.local.adapter import register_local_tool
-from janito.tools.loop_protection_decorator import protect_against_loops
-
-from rich import print as rich_print
-from janito.i18n import tr
-from rich.panel import Panel
-from prompt_toolkit import PromptSession
-from prompt_toolkit.key_binding import KeyBindings
-from prompt_toolkit.enums import EditingMode
-from prompt_toolkit.formatted_text import HTML
-from janito.cli.chat_mode.prompt_style import chat_shell_style
-from prompt_toolkit.styles import Style
-
-toolbar_style = Style.from_dict({"bottom-toolbar": "fg:yellow bg:darkred"})
-
-
-@register_local_tool
-class AskUserTool(ToolBase):
-    """
-    Prompts the user for clarification or input with a question.
-
-    Args:
-        question (str): The question to ask the user. This parameter is required and should be a string containing the prompt or question to display to the user.
-    Returns:
-        str: The user's response as a string. Example:
-            - "Yes"
-            - "No"
-            - "Some detailed answer..."
-    """
-
-    permissions = ToolPermissions(read=True)
-    tool_name = "ask_user"
-
-    @protect_against_loops(max_calls=5, time_window=10.0, key_field="question")
-    def run(self, question: str) -> str:
-
-        print()  # Print an empty line before the question panel
-        rich_print(Panel.fit(question, title=tr("Question"), style="cyan"))
-
-        bindings = KeyBindings()
-        mode = {"multiline": False}
-
-        @bindings.add("c-r")
-        def _(event):
-            pass
-
-        @bindings.add("f12")
-        def _(event):
-            buf = event.app.current_buffer
-            buf.text = "Do It"
-            buf.validate_and_handle()
-
-        @bindings.add("f2")
-        def _(event):
-            buf = event.app.current_buffer
-            buf.text = "F2"
-            buf.validate_and_handle()
-
-        # Use shared CLI styles
-
-        # prompt_style contains the prompt area and input background
-        # toolbar_style contains the bottom-toolbar styling
-
-        # Use the shared chat_shell_style for input styling only
-        style = chat_shell_style
-
-        def get_toolbar():
-            f12_hint = " F2: F2 | F12: Do It"
-            if mode["multiline"]:
-                return HTML(
-                    f"<b>Multiline mode (Esc+Enter to submit). Type /single to switch.</b>{f12_hint}"
-                )
-            else:
-                return HTML(
-                    f"<b>Single-line mode (Enter to submit). Type /multi for multiline.</b>{f12_hint}"
-                )
-
-        session = PromptSession(
-            multiline=False,
-            key_bindings=bindings,
-            editing_mode=EditingMode.EMACS,
-            bottom_toolbar=get_toolbar,
-            style=style,
-        )
-
-        prompt_icon = HTML("<inputline>💬 </inputline>")
-
-        while True:
-            response = session.prompt(prompt_icon)
-            if not mode["multiline"] and response.strip() == "/multi":
-                mode["multiline"] = True
-                session.multiline = True
-                continue
-            elif mode["multiline"] and response.strip() == "/single":
-                mode["multiline"] = False
-                session.multiline = False
-                continue
-            else:
-                sanitized = response.strip()
-                try:
-                    sanitized.encode("utf-8")
-                except UnicodeEncodeError:
-                    sanitized = sanitized.encode("utf-8", errors="replace").decode(
-                        "utf-8"
-                    )
-                    rich_print(
-                        "[yellow]Warning: Some characters in your input were not valid UTF-8 and have been replaced.[/yellow]"
-                    )
-                return sanitized

janito/plugins/web/__init__.py

@@ -1,7 +0,0 @@
-"""
-Web Tools Plugin Package
-
-Contains web scraping, browsing, and URL operations.
-"""
-
-__all__ = ["webtools"]

janito/plugins/web/webtools/__init__.py

@@ -1,23 +0,0 @@
-"""
-Web Tools Plugin
-
-Web scraping, browsing, and URL operations.
-"""
-
-from typing import Optional, Dict, List
-
-
-def open_url(url: str) -> str:
-    """Open URLs in default browser"""
-    return f"open_url(url='{url}')"
-
-
-def open_html_in_browser(path: str) -> str:
-    """Open local HTML files in browser"""
-    return f"open_html_in_browser(path='{path}')"
-
-
-# Plugin metadata
-__plugin_name__ = "web.webtools"
-__plugin_description__ = "Web scraping, browsing, and URL operations"
-__plugin_tools__ = [open_url, open_html_in_browser]

janito/providers/together/__init__.py

@@ -1 +0,0 @@
-# Together AI provider for Janito

janito/providers/together/model_info.py

@@ -1,69 +0,0 @@
-"""
-Model specifications for Together AI provider.
-"""
-
-MODEL_SPECS = {
-    "allenai/OLMo-2-0325-32B-Instruct": {
-        "max_tokens": 32768,
-        "max_input_tokens": 32768,
-        "max_output_tokens": 32768,
-        "description": "OLMo 2 32B Instruct - Fully open language model from AllenAI",
-        "supports_tools": True,
-        "supports_system_prompt": True,
-        "supports_streaming": True,
-    },
-    "allenai/OLMo-2-1124-7B-Instruct": {
-        "max_tokens": 32768,
-        "max_input_tokens": 32768,
-        "max_output_tokens": 32768,
-        "description": "OLMo 2 7B Instruct - Fully open language model from AllenAI",
-        "supports_tools": True,
-        "supports_system_prompt": True,
-        "supports_streaming": True,
-    },
-    "allenai/OLMo-2-0425-1B": {
-        "max_tokens": 32768,
-        "max_input_tokens": 32768,
-        "max_output_tokens": 32768,
-        "description": "OLMo 2 1B - Fully open language model from AllenAI",
-        "supports_tools": True,
-        "supports_system_prompt": True,
-        "supports_streaming": True,
-    },
-    "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo": {
-        "max_tokens": 8192,
-        "max_input_tokens": 128000,
-        "max_output_tokens": 8192,
-        "description": "Llama 3.1 8B Instruct Turbo",
-        "supports_tools": True,
-        "supports_system_prompt": True,
-        "supports_streaming": True,
-    },
-    "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo": {
-        "max_tokens": 8192,
-        "max_input_tokens": 128000,
-        "max_output_tokens": 8192,
-        "description": "Llama 3.1 70B Instruct Turbo",
-        "supports_tools": True,
-        "supports_system_prompt": True,
-        "supports_streaming": True,
-    },
-    "mistralai/Mixtral-8x7B-Instruct-v0.1": {
-        "max_tokens": 32768,
-        "max_input_tokens": 32768,
-        "max_output_tokens": 32768,
-        "description": "Mixtral 8x7B Instruct",
-        "supports_tools": True,
-        "supports_system_prompt": True,
-        "supports_streaming": True,
-    },
-    "deepseek-ai/deepseek-llm-67b-chat": {
-        "max_tokens": 4096,
-        "max_input_tokens": 4096,
-        "max_output_tokens": 4096,
-        "description": "DeepSeek LLM 67B Chat",
-        "supports_tools": True,
-        "supports_system_prompt": True,
-        "supports_streaming": True,
-    },
-}

janito/providers/together/provider.py

@@ -1,108 +0,0 @@
-from janito.llm.provider import LLMProvider
-from janito.llm.model import LLMModelInfo
-from janito.llm.auth import LLMAuthManager
-from janito.llm.driver_config import LLMDriverConfig
-from janito.drivers.openai.driver import OpenAIModelDriver
-from janito.tools import get_local_tools_adapter
-from janito.providers.registry import LLMProviderRegistry
-from .model_info import MODEL_SPECS
-from queue import Queue
-
-available = OpenAIModelDriver.available
-unavailable_reason = OpenAIModelDriver.unavailable_reason
-
-
-class TogetherProvider(LLMProvider):
-    name = 'together'
-    NAME = 'together'
-    MAINTAINER = 'Janito Team'
-    MODEL_SPECS = MODEL_SPECS
-    DEFAULT_MODEL = 'allenai/OLMo-2-0325-32B-Instruct'
-
-    def __init__(
-        self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
-    ):
-        self._tools_adapter = get_local_tools_adapter()
-        self._driver = None
-
-        if not self.available:
-            return
-
-        self._initialize_config(auth_manager, config)
-        self._setup_model_config()
-
-    def _initialize_config(self, auth_manager, config):
-        self.auth_manager = auth_manager or LLMAuthManager()
-        self._api_key = self.auth_manager.get_credentials(type(self).NAME)
-        if not self._api_key:
-            from janito.llm.auth_utils import handle_missing_api_key
-            handle_missing_api_key(self.name, 'TOGETHER_API_KEY')
-
-        self._driver_config = config or LLMDriverConfig(model=None)
-        if not self._driver_config.model:
-            self._driver_config.model = self.DEFAULT_MODEL
-        if not self._driver_config.api_key:
-            self._driver_config.api_key = self._api_key
-
-        self._driver_config.base_url = 'https://api.together.xyz/v1'
-
-    def _setup_model_config(self):
-        model_name = self._driver_config.model
-        model_spec = self.MODEL_SPECS.get(model_name)
-
-        if hasattr(self._driver_config, 'max_tokens'):
-            self._driver_config.max_tokens = None
-        if hasattr(self._driver_config, 'max_completion_tokens'):
-            self._driver_config.max_completion_tokens = None
-
-        if model_spec:
-            max_tokens = getattr(model_spec, 'max_tokens', None)
-            if max_tokens and max_tokens != 'N/A':
-                self._driver_config.max_tokens = int(max_tokens)
-
-        self.fill_missing_device_info(self._driver_config)
-
-    @property
-    def driver(self) -> OpenAIModelDriver:
-        if not self.available:
-            raise ImportError(f'TogetherProvider unavailable: {self.unavailable_reason}')
-        return self._driver
-
-    @property
-    def available(self):
-        return available
-
-    @property
-    def unavailable_reason(self):
-        return unavailable_reason
-
-    def create_driver(self):
-        driver = OpenAIModelDriver(
-            tools_adapter=self._tools_adapter, provider_name=self.NAME
-        )
-        driver.config = self._driver_config
-        return driver
-
-    def create_agent(self, tools_adapter=None, agent_name: str = None, **kwargs):
-        from janito.llm.agent import LLMAgent
-        if tools_adapter is None:
-            tools_adapter = get_local_tools_adapter()
-        raise NotImplementedError(
-            'create_agent must be constructed via new factory using input/output queues and config.'
-        )
-
-    @property
-    def model_name(self):
-        return self._driver_config.model
-
-    @property
-    def driver_config(self):
-        return self._driver_config
-
-    def execute_tool(self, tool_name: str, event_bus, *args, **kwargs):
-        self._tools_adapter.event_bus = event_bus
-        return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
-
-
-LLMProviderRegistry.register(TogetherProvider.NAME, TogetherProvider)
-

janito/tools/blocked_sites.py

@@ -1,74 +0,0 @@
-"""Blocked sites management for fetch_url tool to prevent access to known problematic sites."""
-
-from pathlib import Path
-from typing import Set
-from urllib.parse import urlparse
-
-
-class BlockedSitesManager:
-    """Manages blocked sites for the fetch_url tool using the local blocked.txt file."""
-
-    def __init__(self):
-        # Use package data directory for blocked.txt
-        import janito
-        package_dir = Path(janito.__file__).parent
-        self.blocked_file_path = package_dir / "data" / "blocked.txt"
-        self._blocked_sites = self._load_blocked_sites()
-
-    def _load_blocked_sites(self) -> Set[str]:
-        """Load blocked sites from the blocked.txt file."""
-        blocked = set()
-        
-        if self.blocked_file_path.exists():
-            try:
-                with open(self.blocked_file_path, "r", encoding="utf-8") as f:
-                    for line in f:
-                        line = line.strip()
-                        if line and not line.startswith("#"):
-                            # Extract domain from URL if it's a full URL
-                            if line.startswith("http://") or line.startswith("https://"):
-                                parsed = urlparse(line)
-                                domain = parsed.netloc
-                                if domain:
-                                    blocked.add(domain.lower())
-                            else:
-                                # Assume it's already a domain
-                                blocked.add(line.lower())
-            except IOError:
-                pass
-        
-        return blocked
-
-    def is_url_blocked(self, url: str) -> bool:
-        """Check if a URL is blocked."""
-        if not self._blocked_sites:
-            return False
-
-        try:
-            parsed = urlparse(url)
-            domain = parsed.netloc.lower()
-
-            # Check exact matches and subdomain matches
-            for blocked in self._blocked_sites:
-                if domain == blocked or domain.endswith("." + blocked):
-                    return True
-
-            return False
-        except Exception:
-            return False  # Invalid URLs are not blocked by default
-
-    def get_blocked_sites(self) -> list[str]:
-        """Get the list of blocked sites."""
-        return sorted(self._blocked_sites)
-
-
-# Global singleton
-_blocked_sites_manager = None
-
-
-def get_blocked_sites_manager() -> BlockedSitesManager:
-    """Get the global blocked sites manager instance."""
-    global _blocked_sites_manager
-    if _blocked_sites_manager is None:
-        _blocked_sites_manager = BlockedSitesManager()
-    return _blocked_sites_manager

janito/tools/cli_initializer.py

@@ -1,88 +0,0 @@
-"""
-CLI-specific tool initialization for janito.
-
-This module provides functions to initialize tools specifically for CLI usage,
-handling circular imports and ensuring proper registration.
-"""
-
-import sys
-from pathlib import Path
-from typing import List, Optional
-
-# Ensure current directory is in path
-sys.path.insert(0, str(Path.cwd()))
-
-
-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.tools.permissions import set_global_allowed_permissions
-        from janito.tools.tool_base import ToolPermissions
-
-        # Create adapter
-        adapter = LocalToolsAdapter()
-
-        # Set permissions for CLI
-        set_global_allowed_permissions(
-            ToolPermissions(read=True, write=True, execute=True)
-        )
-
-        # Core plugins to load
-        core_plugins = [
-            "core.filemanager",
-            "core.codeanalyzer",
-            "core.system",
-            "core.imagedisplay",
-            "dev.pythondev",
-            "dev.visualization",
-        ]
-
-        loaded_count = 0
-        for plugin_name in core_plugins:
-            plugin = load_core_plugin(plugin_name)
-            if plugin:
-                tools = plugin.get_tools()
-                for tool_class in tools:
-                    try:
-                        adapter.register_tool(tool_class)
-                        loaded_count += 1
-                    except ValueError:
-                        # Tool already registered, skip
-                        pass
-
-        return adapter, loaded_count
-
-    except Exception as e:
-        print(f"Error initializing CLI tools: {e}", file=sys.stderr)
-        return None, 0
-
-
-def get_cli_tools_adapter():
-    """Get a CLI-initialized tools adapter."""
-    adapter, count = initialize_cli_tools()
-    if adapter and count > 0:
-        return adapter
-    return None
-
-
-def list_cli_tools():
-    """List all available CLI tools."""
-    adapter = get_cli_tools_adapter()
-    if not adapter:
-        return []
-
-    return adapter.list_tools()
-
-
-if __name__ == "__main__":
-    adapter, count = initialize_cli_tools()
-    if adapter:
-        tools = adapter.list_tools()
-        print(f"CLI initialized {count} tools")
-        print(f"Available tools: {len(tools)}")
-        for tool in sorted(tools):
-            print(f"  - {tool}")
-    else:
-        print("Failed to initialize CLI tools")

janito/tools/initialize.py

@@ -1,70 +0,0 @@
-"""
-Initialize janito tools for CLI and programmatic usage.
-
-This module provides functions to load core plugins and register their tools
-with the local tools adapter.
-"""
-
-import sys
-from pathlib import Path
-from typing import List, Optional
-
-from janito.plugin_system.core_loader_fixed import load_core_plugin
-from janito.tools.adapters.local.adapter import LocalToolsAdapter
-
-
-def initialize_tools(adapter: Optional[LocalToolsAdapter] = None) -> LocalToolsAdapter:
-    """
-    Initialize all janito tools by loading core plugins and registering tools.
-
-    Args:
-        adapter: LocalToolsAdapter instance to register tools with.
-                If None, creates a new instance.
-
-    Returns:
-        LocalToolsAdapter with all tools registered.
-    """
-    if adapter is None:
-        adapter = LocalToolsAdapter()
-
-    # Core plugins to load
-    core_plugins = [
-        "core.filemanager",
-        "core.codeanalyzer",
-        "core.system",
-        "core.imagedisplay",
-        "dev.pythondev",
-        "dev.visualization",
-    ]
-
-    loaded_count = 0
-    for plugin_name in core_plugins:
-        plugin = load_core_plugin(plugin_name)
-        if plugin:
-            tools = plugin.get_tools()
-            for tool_class in tools:
-                adapter.register_tool(tool_class)
-                loaded_count += 1
-
-    return adapter
-
-
-def get_initialized_adapter() -> LocalToolsAdapter:
-    """Get a pre-initialized LocalToolsAdapter with all tools registered."""
-    return initialize_tools()
-
-
-def list_available_tools() -> List[str]:
-    """Get a list of all available tool names."""
-    adapter = get_initialized_adapter()
-    return sorted(list(adapter._tools.keys()))
-
-
-if __name__ == "__main__":
-    adapter = initialize_tools()
-    tools = sorted(list(adapter._tools.keys()))
-
-    print(f"Initialized {len(tools)} tools")
-    print("Available tools:")
-    for tool_name in tools:
-        print(f"  - {tool_name}")