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

janito/cli/core/unsetters.py

@@ -1,54 +1,54 @@
-from janito.config import config as global_config
-
-
-def handle_unset(args):
-    unset_arg = getattr(args, "unset", None)
-    if not unset_arg:
-        return False
-    key = unset_arg.strip().replace("-", "_")
-    if "." in key:
-        # Provider or model-specific keys
-        parts = key.split(".")
-        if len(parts) == 2:
-            provider, subkey = parts
-            current_val = (
-                global_config.file_config.get("providers", {})
-                .get(provider, {})
-                .get(subkey)
-            )
-            if current_val is not None:
-                del global_config.file_config["providers"][provider][subkey]
-                global_config.save()
-                print(f"{key}={current_val} was removed.")
-                return True
-        elif len(parts) == 3:
-            provider, model, subkey = parts
-            model_conf = (
-                global_config.file_config.get("providers", {})
-                .get(provider, {})
-                .get("models", {})
-                .get(model, {})
-            )
-            current_val = model_conf.get(subkey)
-            if current_val is not None:
-                del global_config.file_config["providers"][provider]["models"][model][
-                    subkey
-                ]
-                global_config.save()
-                print(f"{key}={current_val} was removed.")
-                return True
-    else:
-        current_val = global_config.file_config.get(key)
-        if current_val is not None:
-            del global_config.file_config[key]
-            global_config.save()
-            print(f"{key}={current_val} was removed.")
-            return True
-    if "=" in unset_arg:
-        provided_key = unset_arg.split("=")[0].strip()
-        print(
-            f"Error: --unset expected a key, not key=value. Did you mean: --unset {provided_key}?"
-        )
-    else:
-        print(f"Error: no value set for {key} (cannot remove)")
-    return True
+from janito.config import config as global_config
+
+
+def handle_unset(args):
+    unset_arg = getattr(args, "unset", None)
+    if not unset_arg:
+        return False
+    key = unset_arg.strip().replace("-", "_")
+    if "." in key:
+        # Provider or model-specific keys
+        parts = key.split(".")
+        if len(parts) == 2:
+            provider, subkey = parts
+            current_val = (
+                global_config.file_config.get("providers", {})
+                .get(provider, {})
+                .get(subkey)
+            )
+            if current_val is not None:
+                del global_config.file_config["providers"][provider][subkey]
+                global_config.save()
+                print(f"{key}={current_val} was removed.")
+                return True
+        elif len(parts) == 3:
+            provider, model, subkey = parts
+            model_conf = (
+                global_config.file_config.get("providers", {})
+                .get(provider, {})
+                .get("models", {})
+                .get(model, {})
+            )
+            current_val = model_conf.get(subkey)
+            if current_val is not None:
+                del global_config.file_config["providers"][provider]["models"][model][
+                    subkey
+                ]
+                global_config.save()
+                print(f"{key}={current_val} was removed.")
+                return True
+    else:
+        current_val = global_config.file_config.get(key)
+        if current_val is not None:
+            del global_config.file_config[key]
+            global_config.save()
+            print(f"{key}={current_val} was removed.")
+            return True
+    if "=" in unset_arg:
+        provided_key = unset_arg.split("=")[0].strip()
+        print(
+            f"Error: --unset expected a key, not key=value. Did you mean: --unset {provided_key}?"
+        )
+    else:
+        print(f"Error: no value set for {key} (cannot remove)")
+    return True

janito/cli/single_shot_mode/__init__.py

@@ -1,6 +1,6 @@
-# janito.cli.single_shot_mode package
-from .handler import PromptHandler
-
-__all__ = [
-    "PromptHandler",
-]
+# janito.cli.single_shot_mode package
+from .handler import PromptHandler
+
+__all__ = [
+    "PromptHandler",
+]

janito/config.py

@@ -1,5 +1,5 @@
-# Shared Janito ConfigManager singleton
-from janito.config_manager import ConfigManager
-
-# Only one global instance! Used by CLI, provider_config, others:
-config = ConfigManager(config_path=None)
+# Shared Janito ConfigManager singleton
+from janito.config_manager import ConfigManager
+
+# Only one global instance! Used by CLI, provider_config, others:
+config = ConfigManager(config_path=None)

janito/config_manager.py

@@ -1,112 +1,112 @@
-import json
-from pathlib import Path
-from threading import Lock
-
-
-class ConfigManager:
-    """
-    Unified configuration manager supporting:
-      - Defaults
-      - File-based configuration
-      - Runtime overrides (e.g., CLI args)
-    """
-
-    _instance = None
-    _lock = Lock()
-
-    def __new__(cls, *args, **kwargs):
-        with cls._lock:
-            if not cls._instance:
-                cls._instance = super(ConfigManager, cls).__new__(cls)
-        return cls._instance
-
-    def __init__(self, config_path=None, defaults=None, runtime_overrides=None):
-        # Lazy single-init
-        if hasattr(self, "_initialized") and self._initialized:
-            return
-        self._initialized = True
-
-        self.config_path = Path(config_path or Path.home() / ".janito" / "config.json")
-        self.defaults = dict(defaults) if defaults else {}
-        self.file_config = {}
-        self.runtime_overrides = dict(runtime_overrides) if runtime_overrides else {}
-        self._load_file_config()
-
-    def _load_file_config(self):
-        if self.config_path.exists():
-            with open(self.config_path, "r", encoding="utf-8") as f:
-                try:
-                    self.file_config = json.load(f)
-                except Exception:
-                    self.file_config = {}
-        else:
-            self.file_config = {}
-
-    def save(self):
-        self.config_path.parent.mkdir(parents=True, exist_ok=True)
-        with open(self.config_path, "w", encoding="utf-8") as f:
-            json.dump(self.file_config, f, indent=2)
-            f.write("\n")
-
-    def get(self, key, default=None):
-        # Precedence: runtime_overrides > file_config > defaults
-        for layer in (self.runtime_overrides, self.file_config, self.defaults):
-            if key in layer and layer[key] is not None:
-                return layer[key]
-        return default
-
-    def runtime_set(self, key, value):
-        self.runtime_overrides[key] = value
-
-    def file_set(self, key, value):
-        # Always reload, update, and persist
-        self._load_file_config()
-        self.file_config[key] = value
-        with open(self.config_path, "w", encoding="utf-8") as f:
-            json.dump(self.file_config, f, indent=2)
-            f.write("\n")
-
-    def all(self, layered=False):
-        merged = dict(self.defaults)
-        merged.update(self.file_config)
-        merged.update(self.runtime_overrides)
-        if layered:
-            # Only file+runtime, i.e., what is saved to disk
-            d = dict(self.file_config)
-            d.update(self.runtime_overrides)
-            return d
-        return merged
-
-    # Namespaced provider/model config
-    def get_provider_config(self, provider, default=None):
-        providers = self.file_config.get("providers") or {}
-        return providers.get(provider) or (default or {})
-
-    def set_provider_config(self, provider, key, value):
-        if "providers" not in self.file_config:
-            self.file_config["providers"] = {}
-        if provider not in self.file_config["providers"]:
-            self.file_config["providers"][provider] = {}
-        self.file_config["providers"][provider][key] = value
-
-    def get_provider_model_config(self, provider, model, default=None):
-        return (
-            self.file_config.get("providers")
-            or {}.get(provider, {}).get("models", {}).get(model)
-            or (default or {})
-        )
-
-    def set_provider_model_config(self, provider, model, key, value):
-        if "providers" not in self.file_config:
-            self.file_config["providers"] = {}
-        if provider not in self.file_config["providers"]:
-            self.file_config["providers"][provider] = {}
-        if "models" not in self.file_config["providers"][provider]:
-            self.file_config["providers"][provider]["models"] = {}
-        if model not in self.file_config["providers"][provider]["models"]:
-            self.file_config["providers"][provider]["models"][model] = {}
-        self.file_config["providers"][provider]["models"][model][key] = value
-
-    # Support loading runtime overrides after init (e.g. after parsing CLI args)
-    def apply_runtime_overrides(self, overrides_dict):
-        self.runtime_overrides.update(overrides_dict)
+import json
+from pathlib import Path
+from threading import Lock
+
+
+class ConfigManager:
+    """
+    Unified configuration manager supporting:
+      - Defaults
+      - File-based configuration
+      - Runtime overrides (e.g., CLI args)
+    """
+
+    _instance = None
+    _lock = Lock()
+
+    def __new__(cls, *args, **kwargs):
+        with cls._lock:
+            if not cls._instance:
+                cls._instance = super(ConfigManager, cls).__new__(cls)
+        return cls._instance
+
+    def __init__(self, config_path=None, defaults=None, runtime_overrides=None):
+        # Lazy single-init
+        if hasattr(self, "_initialized") and self._initialized:
+            return
+        self._initialized = True
+
+        self.config_path = Path(config_path or Path.home() / ".janito" / "config.json")
+        self.defaults = dict(defaults) if defaults else {}
+        self.file_config = {}
+        self.runtime_overrides = dict(runtime_overrides) if runtime_overrides else {}
+        self._load_file_config()
+
+    def _load_file_config(self):
+        if self.config_path.exists():
+            with open(self.config_path, "r", encoding="utf-8") as f:
+                try:
+                    self.file_config = json.load(f)
+                except Exception:
+                    self.file_config = {}
+        else:
+            self.file_config = {}
+
+    def save(self):
+        self.config_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.config_path, "w", encoding="utf-8") as f:
+            json.dump(self.file_config, f, indent=2)
+            f.write("\n")
+
+    def get(self, key, default=None):
+        # Precedence: runtime_overrides > file_config > defaults
+        for layer in (self.runtime_overrides, self.file_config, self.defaults):
+            if key in layer and layer[key] is not None:
+                return layer[key]
+        return default
+
+    def runtime_set(self, key, value):
+        self.runtime_overrides[key] = value
+
+    def file_set(self, key, value):
+        # Always reload, update, and persist
+        self._load_file_config()
+        self.file_config[key] = value
+        with open(self.config_path, "w", encoding="utf-8") as f:
+            json.dump(self.file_config, f, indent=2)
+            f.write("\n")
+
+    def all(self, layered=False):
+        merged = dict(self.defaults)
+        merged.update(self.file_config)
+        merged.update(self.runtime_overrides)
+        if layered:
+            # Only file+runtime, i.e., what is saved to disk
+            d = dict(self.file_config)
+            d.update(self.runtime_overrides)
+            return d
+        return merged
+
+    # Namespaced provider/model config
+    def get_provider_config(self, provider, default=None):
+        providers = self.file_config.get("providers") or {}
+        return providers.get(provider) or (default or {})
+
+    def set_provider_config(self, provider, key, value):
+        if "providers" not in self.file_config:
+            self.file_config["providers"] = {}
+        if provider not in self.file_config["providers"]:
+            self.file_config["providers"][provider] = {}
+        self.file_config["providers"][provider][key] = value
+
+    def get_provider_model_config(self, provider, model, default=None):
+        return (
+            self.file_config.get("providers")
+            or {}.get(provider, {}).get("models", {}).get(model)
+            or (default or {})
+        )
+
+    def set_provider_model_config(self, provider, model, key, value):
+        if "providers" not in self.file_config:
+            self.file_config["providers"] = {}
+        if provider not in self.file_config["providers"]:
+            self.file_config["providers"][provider] = {}
+        if "models" not in self.file_config["providers"][provider]:
+            self.file_config["providers"][provider]["models"] = {}
+        if model not in self.file_config["providers"][provider]["models"]:
+            self.file_config["providers"][provider]["models"][model] = {}
+        self.file_config["providers"][provider]["models"][model][key] = value
+
+    # Support loading runtime overrides after init (e.g. after parsing CLI args)
+    def apply_runtime_overrides(self, overrides_dict):
+        self.runtime_overrides.update(overrides_dict)

janito/drivers/anthropic/driver.py

@@ -1,113 +1,113 @@
-from janito.llm.driver import LLMDriver
-from janito.llm.driver_config import LLMDriverConfig
-from janito.driver_events import (
-    GenerationStarted,
-    GenerationFinished,
-    RequestStarted,
-    RequestFinished,
-    ResponseReceived,
-)
-from janito.llm.message_parts import TextMessagePart
-import uuid
-import traceback
-import time
-
-# Safe import of anthropic SDK
-try:
-    import anthropic
-
-    DRIVER_AVAILABLE = True
-    DRIVER_UNAVAILABLE_REASON = None
-except ImportError:
-    DRIVER_AVAILABLE = False
-    DRIVER_UNAVAILABLE_REASON = "Missing dependency: anthropic (pip install anthropic)"
-
-
-class AnthropicModelDriver(LLMDriver):
-    available = False
-    unavailable_reason = "AnthropicModelDriver is not implemented yet."
-
-    @classmethod
-    def is_available(cls):
-        return cls.available
-
-    """
-    LLMDriver for Anthropic's Claude API (v3), using the anthropic SDK.
-    """
-    required_config = ["api_key", "model"]
-
-    def __init__(self, tools_adapter=None):
-        raise ImportError(self.unavailable_reason)
-
-    def _create_client(self):
-        try:
-            import anthropic
-        except ImportError:
-            raise Exception(
-                "The 'anthropic' Python SDK is required. Please install via `pip install anthropic`."
-            )
-        return anthropic.Anthropic(api_key=self.api_key)
-
-    def _run_generation(
-        self, messages_or_prompt, system_prompt=None, tools=None, **kwargs
-    ):
-        request_id = str(uuid.uuid4())
-        client = self._create_client()
-        try:
-            prompt = ""
-            if isinstance(messages_or_prompt, str):
-                prompt = messages_or_prompt
-            elif isinstance(messages_or_prompt, list):
-                chat = []
-                for msg in messages_or_prompt:
-                    if msg.get("role") == "user":
-                        chat.append("Human: " + msg.get("content", ""))
-                    elif msg.get("role") == "assistant":
-                        chat.append("Assistant: " + msg.get("content", ""))
-                prompt = "\n".join(chat)
-            if system_prompt:
-                prompt = f"System: {system_prompt}\n{prompt}"
-
-            self.publish(
-                GenerationStarted,
-                request_id,
-                conversation_history=list(getattr(self, "_history", [])),
-            )
-            self.publish(RequestStarted, request_id, payload={})
-            start_time = time.time()
-            response = client.completions.create(
-                model=self.model_name,
-                max_tokens_to_sample=int(getattr(self.config, "max_response", 1024)),
-                prompt=prompt,
-                temperature=float(getattr(self.config, "default_temp", 0.7)),
-            )
-            duration = time.time() - start_time
-            content = response.completion if hasattr(response, "completion") else None
-            self.publish(
-                RequestFinished,
-                request_id,
-                response=content,
-                status=RequestStatus.SUCCESS,
-                usage={},
-            )
-            parts = []
-            if content:
-                parts.append(TextMessagePart(content=content))
-            self.publish(
-                ResponseReceived,
-                request_id=request_id,
-                parts=parts,
-                tool_results=[],
-                timestamp=time.time(),
-                metadata={"raw_response": response},
-            )
-            self.publish(GenerationFinished, request_id, total_turns=1)
-        except Exception as e:
-            self.publish(
-                RequestFinished,
-                request_id,
-                status=RequestStatus.ERROR,
-                error=str(e),
-                exception=e,
-                traceback=traceback.format_exc(),
-            )
+from janito.llm.driver import LLMDriver
+from janito.llm.driver_config import LLMDriverConfig
+from janito.driver_events import (
+    GenerationStarted,
+    GenerationFinished,
+    RequestStarted,
+    RequestFinished,
+    ResponseReceived,
+)
+from janito.llm.message_parts import TextMessagePart
+import uuid
+import traceback
+import time
+
+# Safe import of anthropic SDK
+try:
+    import anthropic
+
+    DRIVER_AVAILABLE = True
+    DRIVER_UNAVAILABLE_REASON = None
+except ImportError:
+    DRIVER_AVAILABLE = False
+    DRIVER_UNAVAILABLE_REASON = "Missing dependency: anthropic (pip install anthropic)"
+
+
+class AnthropicModelDriver(LLMDriver):
+    available = False
+    unavailable_reason = "AnthropicModelDriver is not implemented yet."
+
+    @classmethod
+    def is_available(cls):
+        return cls.available
+
+    """
+    LLMDriver for Anthropic's Claude API (v3), using the anthropic SDK.
+    """
+    required_config = ["api_key", "model"]
+
+    def __init__(self, tools_adapter=None):
+        raise ImportError(self.unavailable_reason)
+
+    def _create_client(self):
+        try:
+            import anthropic
+        except ImportError:
+            raise Exception(
+                "The 'anthropic' Python SDK is required. Please install via `pip install anthropic`."
+            )
+        return anthropic.Anthropic(api_key=self.api_key)
+
+    def _run_generation(
+        self, messages_or_prompt, system_prompt=None, tools=None, **kwargs
+    ):
+        request_id = str(uuid.uuid4())
+        client = self._create_client()
+        try:
+            prompt = ""
+            if isinstance(messages_or_prompt, str):
+                prompt = messages_or_prompt
+            elif isinstance(messages_or_prompt, list):
+                chat = []
+                for msg in messages_or_prompt:
+                    if msg.get("role") == "user":
+                        chat.append("Human: " + msg.get("content", ""))
+                    elif msg.get("role") == "assistant":
+                        chat.append("Assistant: " + msg.get("content", ""))
+                prompt = "\n".join(chat)
+            if system_prompt:
+                prompt = f"System: {system_prompt}\n{prompt}"
+
+            self.publish(
+                GenerationStarted,
+                request_id,
+                conversation_history=list(getattr(self, "_history", [])),
+            )
+            self.publish(RequestStarted, request_id, payload={})
+            start_time = time.time()
+            response = client.completions.create(
+                model=self.model_name,
+                max_tokens_to_sample=int(getattr(self.config, "max_response", 1024)),
+                prompt=prompt,
+                temperature=float(getattr(self.config, "default_temp", 0.7)),
+            )
+            duration = time.time() - start_time
+            content = response.completion if hasattr(response, "completion") else None
+            self.publish(
+                RequestFinished,
+                request_id,
+                response=content,
+                status=RequestStatus.SUCCESS,
+                usage={},
+            )
+            parts = []
+            if content:
+                parts.append(TextMessagePart(content=content))
+            self.publish(
+                ResponseReceived,
+                request_id=request_id,
+                parts=parts,
+                tool_results=[],
+                timestamp=time.time(),
+                metadata={"raw_response": response},
+            )
+            self.publish(GenerationFinished, request_id, total_turns=1)
+        except Exception as e:
+            self.publish(
+                RequestFinished,
+                request_id,
+                status=RequestStatus.ERROR,
+                error=str(e),
+                exception=e,
+                traceback=traceback.format_exc(),
+            )