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

janito/providers/deepseek/provider.py

@@ -1,91 +1,94 @@
-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 DeepseekProvider(LLMProvider):
-    name = "deepseek"
-    maintainer = "Needs maintainer"
-    MODEL_SPECS = MODEL_SPECS
-    DEFAULT_MODEL = "deepseek-chat"  # Options: deepseek-chat, deepseek-reasoner
-
-    def __init__(
-        self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
-    ):
-        if not self.available:
-            self._driver = None
-        else:
-            self.auth_manager = auth_manager or LLMAuthManager()
-            self._api_key = self.auth_manager.get_credentials(type(self).name)
-            self._tools_adapter = get_local_tools_adapter()
-            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
-            # Set DeepSeek public endpoint as default base_url if not provided
-            if not getattr(self._driver_config, "base_url", None):
-                self._driver_config.base_url = "https://api.deepseek.com/v1"
-            self.fill_missing_device_info(self._driver_config)
-            self._driver = None  # to be provided by factory/agent
-
-    @property
-    def driver(self) -> OpenAIModelDriver:
-        if not self.available:
-            raise ImportError(f"OpenAIProvider 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):
-        """
-        Creates and returns a new OpenAIModelDriver instance with input/output queues.
-        """
-        driver = OpenAIModelDriver(
-            tools_adapter=self._tools_adapter, provider_name=self.name
-        )
-        driver.config = self._driver_config
-        # NOTE: The caller is responsible for calling driver.start() if background processing is needed.
-        return driver
-
-    def create_agent(self, tools_adapter=None, agent_name: str = None, **kwargs):
-        from janito.llm.agent import LLMAgent
-
-        # Always create a new driver with the passed-in tools_adapter
-        if tools_adapter is None:
-            tools_adapter = get_local_tools_adapter()
-        # Should use new-style driver construction via queues/factory (handled elsewhere)
-        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):
-        """Public, read-only access to the provider's LLMDriverConfig object."""
-        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(DeepseekProvider.name, DeepseekProvider)
+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 DeepseekProvider(LLMProvider):
+    name = "deepseek"
+    maintainer = "Needs maintainer"
+    MODEL_SPECS = MODEL_SPECS
+    DEFAULT_MODEL = "deepseek-chat"  # Options: deepseek-chat, deepseek-reasoner
+
+    def __init__(
+        self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
+    ):
+        # Always set a tools adapter so that even if the driver is unavailable,
+        # generic code paths that expect provider.execute_tool() continue to work.
+        self._tools_adapter = get_local_tools_adapter()
+        if not self.available:
+            self._driver = None
+        else:
+            self.auth_manager = auth_manager or LLMAuthManager()
+            self._api_key = self.auth_manager.get_credentials(type(self).name)
+            self._tools_adapter = get_local_tools_adapter()
+            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
+            # Set DeepSeek public endpoint as default base_url if not provided
+            if not getattr(self._driver_config, "base_url", None):
+                self._driver_config.base_url = "https://api.deepseek.com/v1"
+            self.fill_missing_device_info(self._driver_config)
+            self._driver = None  # to be provided by factory/agent
+
+    @property
+    def driver(self) -> OpenAIModelDriver:
+        if not self.available:
+            raise ImportError(f"OpenAIProvider 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):
+        """
+        Creates and returns a new OpenAIModelDriver instance with input/output queues.
+        """
+        driver = OpenAIModelDriver(
+            tools_adapter=self._tools_adapter, provider_name=self.name
+        )
+        driver.config = self._driver_config
+        # NOTE: The caller is responsible for calling driver.start() if background processing is needed.
+        return driver
+
+    def create_agent(self, tools_adapter=None, agent_name: str = None, **kwargs):
+        from janito.llm.agent import LLMAgent
+
+        # Always create a new driver with the passed-in tools_adapter
+        if tools_adapter is None:
+            tools_adapter = get_local_tools_adapter()
+        # Should use new-style driver construction via queues/factory (handled elsewhere)
+        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):
+        """Public, read-only access to the provider's LLMDriverConfig object."""
+        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(DeepseekProvider.name, DeepseekProvider)

janito/providers/google/provider.py

@@ -22,6 +22,9 @@ class GoogleProvider(LLMProvider):
     def __init__(
         self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
     ):
+        # Always have a tools adapter available to avoid AttributeError downstream when
+        # the driver is missing but other logic still relies on tools execution.
+        self._tools_adapter = get_local_tools_adapter()
         if not self.available:
             self._driver = None
         else:

janito/providers/mistralai/provider.py

@@ -24,6 +24,9 @@ class MistralAIProvider(LLMProvider):
     def __init__(
         self, config: LLMDriverConfig = None, auth_manager: LLMAuthManager = None
     ):
+        # Always instantiate a tools adapter so that provider.execute_tool() remains functional
+        # even when the driver cannot be constructed due to missing dependencies.
+        self._tools_adapter = get_local_tools_adapter()
         if not self.available:
             self._driver = None
             return

janito/providers/openai/provider.py

@@ -24,6 +24,10 @@ class OpenAIProvider(LLMProvider):
         self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
     ):
         if not self.available:
+            # Even when the OpenAI driver is unavailable we still need a tools adapter
+            # so that any generic logic that expects `execute_tool()` to work does not
+            # crash with an AttributeError when it tries to access `self._tools_adapter`.
+            self._tools_adapter = get_local_tools_adapter()
             self._driver = None
         else:
             self.auth_manager = auth_manager or LLMAuthManager()

janito/tools/adapters/__init__.py

@@ -1 +1 @@
-# Tools providers package: for plug-and-play tool collections, integrations, and adapters.
+# Tools providers package: for plug-and-play tool collections, integrations, and adapters.

janito/tools/adapters/local/ask_user.py

@@ -1,102 +1,102 @@
-from janito.tools.tool_base import ToolBase
-from janito.tools.adapters.local.adapter import register_local_tool
-
-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.
-
-    Returns:
-        str: The user's response as a string. Example:
-            - "Yes"
-            - "No"
-            - "Some detailed answer..."
-    """
-
-    tool_name = "ask_user"
-
-    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()
-
-        # 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 = ""
-            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
+from janito.tools.tool_base import ToolBase
+from janito.tools.adapters.local.adapter import register_local_tool
+
+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.
+
+    Returns:
+        str: The user's response as a string. Example:
+            - "Yes"
+            - "No"
+            - "Some detailed answer..."
+    """
+
+    tool_name = "ask_user"
+
+    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()
+
+        # 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 = ""
+            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/tools/adapters/local/copy_file.py

@@ -1,84 +1,84 @@
-import os
-import shutil
-from typing import List, Union
-from janito.tools.adapters.local.adapter import register_local_tool
-from janito.tools.tool_base import ToolBase
-from janito.tools.tool_utils import display_path
-from janito.report_events import ReportAction
-from janito.i18n import tr
-
-
-@register_local_tool
-class CopyFileTool(ToolBase):
-    """
-    Copy one or more files to a target directory, or copy a single file to a new file.
-    Args:
-        sources (str): Space-separated path(s) to the file(s) to copy.
-            For multiple sources, provide a single string with paths separated by spaces.
-        target (str): Destination path. If copying multiple sources, this must be an existing directory.
-        overwrite (bool, optional): Overwrite existing files. Default: False.
-            Recommended only after reading the file to be overwritten.
-    Returns:
-        str: Status string for each copy operation.
-    """
-
-    tool_name = "copy_file"
-
-    def run(self, sources: str, target: str, overwrite: bool = False) -> str:
-        source_list = [src for src in sources.split() if src]
-        messages = []
-        if len(source_list) > 1:
-            if not os.path.isdir(target):
-                return tr(
-                    "❗ Target must be an existing directory when copying multiple files: '{target}'",
-                    target=display_path(target),
-                )
-            for src in source_list:
-                if not os.path.isfile(src):
-                    messages.append(
-                        tr(
-                            "❗ Source file does not exist: '{src}'",
-                            src=display_path(src),
-                        )
-                    )
-                    continue
-                dst = os.path.join(target, os.path.basename(src))
-                messages.append(self._copy_one(src, dst, overwrite=overwrite))
-        else:
-            src = source_list[0]
-            if os.path.isdir(target):
-                dst = os.path.join(target, os.path.basename(src))
-            else:
-                dst = target
-            messages.append(self._copy_one(src, dst, overwrite=overwrite))
-        return "\n".join(messages)
-
-    def _copy_one(self, src, dst, overwrite=False) -> str:
-        disp_src = display_path(src)
-        disp_dst = display_path(dst)
-        if not os.path.isfile(src):
-            return tr("❗ Source file does not exist: '{src}'", src=disp_src)
-        if os.path.exists(dst) and not overwrite:
-            return tr(
-                "❗ Target already exists: '{dst}'. Set overwrite=True to replace.",
-                dst=disp_dst,
-            )
-        try:
-            os.makedirs(os.path.dirname(dst), exist_ok=True)
-            shutil.copy2(src, dst)
-            note = (
-                "\n⚠️ Overwrote existing file. (recommended only after reading the file to be overwritten)"
-                if (os.path.exists(dst) and overwrite)
-                else ""
-            )
-            self.report_success(
-                tr("✅ Copied '{src}' to '{dst}'", src=disp_src, dst=disp_dst)
-            )
-            return tr("✅ Copied '{src}' to '{dst}'", src=disp_src, dst=disp_dst) + note
-        except Exception as e:
-            return tr(
-                "❗ Copy failed from '{src}' to '{dst}': {err}",
-                src=disp_src,
-                dst=disp_dst,
-                err=str(e),
-            )
+import os
+import shutil
+from typing import List, Union
+from janito.tools.adapters.local.adapter import register_local_tool
+from janito.tools.tool_base import ToolBase
+from janito.tools.tool_utils import display_path
+from janito.report_events import ReportAction
+from janito.i18n import tr
+
+
+@register_local_tool
+class CopyFileTool(ToolBase):
+    """
+    Copy one or more files to a target directory, or copy a single file to a new file.
+    Args:
+        sources (str): Space-separated path(s) to the file(s) to copy.
+            For multiple sources, provide a single string with paths separated by spaces.
+        target (str): Destination path. If copying multiple sources, this must be an existing directory.
+        overwrite (bool, optional): Overwrite existing files. Default: False.
+            Recommended only after reading the file to be overwritten.
+    Returns:
+        str: Status string for each copy operation.
+    """
+
+    tool_name = "copy_file"
+
+    def run(self, sources: str, target: str, overwrite: bool = False) -> str:
+        source_list = [src for src in sources.split() if src]
+        messages = []
+        if len(source_list) > 1:
+            if not os.path.isdir(target):
+                return tr(
+                    "❗ Target must be an existing directory when copying multiple files: '{target}'",
+                    target=display_path(target),
+                )
+            for src in source_list:
+                if not os.path.isfile(src):
+                    messages.append(
+                        tr(
+                            "❗ Source file does not exist: '{src}'",
+                            src=display_path(src),
+                        )
+                    )
+                    continue
+                dst = os.path.join(target, os.path.basename(src))
+                messages.append(self._copy_one(src, dst, overwrite=overwrite))
+        else:
+            src = source_list[0]
+            if os.path.isdir(target):
+                dst = os.path.join(target, os.path.basename(src))
+            else:
+                dst = target
+            messages.append(self._copy_one(src, dst, overwrite=overwrite))
+        return "\n".join(messages)
+
+    def _copy_one(self, src, dst, overwrite=False) -> str:
+        disp_src = display_path(src)
+        disp_dst = display_path(dst)
+        if not os.path.isfile(src):
+            return tr("❗ Source file does not exist: '{src}'", src=disp_src)
+        if os.path.exists(dst) and not overwrite:
+            return tr(
+                "❗ Target already exists: '{dst}'. Set overwrite=True to replace.",
+                dst=disp_dst,
+            )
+        try:
+            os.makedirs(os.path.dirname(dst), exist_ok=True)
+            shutil.copy2(src, dst)
+            note = (
+                "\n⚠️ Overwrote existing file. (recommended only after reading the file to be overwritten)"
+                if (os.path.exists(dst) and overwrite)
+                else ""
+            )
+            self.report_success(
+                tr("✅ Copied '{src}' to '{dst}'", src=disp_src, dst=disp_dst)
+            )
+            return tr("✅ Copied '{src}' to '{dst}'", src=disp_src, dst=disp_dst) + note
+        except Exception as e:
+            return tr(
+                "❗ Copy failed from '{src}' to '{dst}': {err}",
+                src=disp_src,
+                dst=disp_dst,
+                err=str(e),
+            )