yera 0.1.1__py3-none-any.whl → 0.2.1__py3-none-any.whl

yera/config2/setup_handlers/ollama.py

@@ -0,0 +1,157 @@
+# ruff: noqa: T201
+"""Configuration import handler for Ollama."""
+
+import os
+from typing import Any
+
+import requests as r
+
+from yera.config2.dataclasses import (
+    CredentialsMap,
+    LLMConfig,
+    ModelRegistry,
+)
+from yera.config2.keyring import DevKeyring
+from yera.config2.setup_handlers.base import BaseProviderSetup
+
+
+class OllamaSetup(BaseProviderSetup):
+    """Setup handler for Ollama provider credentials and models.
+
+    Manages connection setup and model fetching for local Ollama.
+    Supports both automatic detection of running Ollama servers and interactive
+    configuration of custom base URLs.
+    """
+
+    def __init__(self):
+        """Initialise the Ollama setup handler."""
+        super().__init__("ollama")
+
+    @staticmethod
+    def _is_ollama_running(base_url: str) -> bool:
+        try:
+            response = r.get(f"{base_url}/api/tags", timeout=2)
+            return response.status_code == 200
+        except Exception:
+            return False
+
+    def detect_creds(self) -> dict[str, str] | None:
+        """Detect Ollama connection from environment or default location.
+
+        Checks OLLAMA_BASE_URL environment variable or defaults to
+        http://localhost:11434. Verifies that Ollama is actually running.
+
+        Returns:
+            Dictionary with "base_url" if Ollama is running, otherwise None.
+        """
+        base_url = os.environ.get("OLLAMA_BASE_URL", "http://localhost:11434")
+
+        if self._is_ollama_running(base_url):
+            return {"base_url": base_url}
+        return None
+
+    def ask_for_creds(self) -> dict[str, str] | None:
+        """Prompt user to configure Ollama connection interactively.
+
+        Allows user to specify a custom base URL or use the default. Verifies
+        that Ollama is running at the specified URL before accepting.
+
+        Returns:
+            Dictionary with "base_url" if Ollama is running at the specified
+            URL, otherwise None if user declines or connection fails.
+        """
+        ask = self._confirm_ask_for_creds()
+        if not ask:
+            return None
+
+        print("  Is Ollama running on a custom URL? (default: http://localhost:11434)")
+        print("  Press Enter to use default, or enter custom URL:")
+        base_url = input(" > ").strip()
+
+        if not base_url:
+            base_url = "http://localhost:11434"
+
+        if not self._is_ollama_running(base_url):
+            print(f"  ⚠️  Cannot connect to Ollama at {base_url}")
+            print("  Make sure Ollama is installed and running: https://ollama.ai")
+            return None
+
+        return {"base_url": base_url}
+
+    def validate_creds(self, creds: dict[str, str]) -> None:
+        """Validate that Ollama is running at the configured URL.
+
+        Args:
+            creds: Dictionary containing "base_url" to validate.
+
+        Raises:
+            ValueError: If Ollama is not running at the specified URL.
+        """
+        base_url = creds.get("base_url", "http://localhost:11434")
+
+        if not self._is_ollama_running(base_url):
+            raise ValueError(
+                f"Cannot connect to Ollama at {base_url}\n"
+                "Make sure Ollama is installed and running.\n"
+                "Install from: https://ollama.ai"
+            )
+
+    def fetch_models(self, creds_map: CredentialsMap) -> ModelRegistry:
+        """Fetch available models from local Ollama instance.
+
+        Retrieves the list of models currently installed in Ollama.
+
+        Args:
+            creds_map: Credentials map containing Ollama provider configuration.
+
+        Returns:
+            ModelRegistry containing LLMConfig entries for all installed
+            Ollama models, or empty registry if none found or on error.
+        """
+        creds = {
+            k: DevKeyring.get(f"providers.{v}")
+            for k, v in creds_map.providers["ollama"].items()
+        }
+
+        base_url = creds.get("base_url", "http://localhost:11434")
+
+        try:
+            response = r.get(f"{base_url}/api/tags", timeout=5)
+            response.raise_for_status()
+            data = response.json()
+
+            models = data.get("models", [])
+
+            if not models:
+                print(
+                    "  ⚠️  No models found. Pull models with: ollama pull <model-name>"
+                )
+                print("  Popular models: llama3.1, mistral, codellama, phi3")
+                return ModelRegistry()
+
+            model_configs = [self._make_model_cfg(m) for m in models]
+
+            names = "  \n   * ".join(m.display_name for m in model_configs)
+            print(f"  Adding {len(model_configs)} LLMs from Ollama:\n   * {names}")
+
+            return ModelRegistry(
+                llm={m.id: m for m in model_configs},
+            )
+
+        except Exception as e:
+            print(f"  ⚠️  Error fetching Ollama models: {e}")
+            return ModelRegistry()
+
+    def _make_model_cfg(self, model: dict[str, Any]) -> LLMConfig:
+        model_name = model["name"]
+
+        display_name = model_name.replace(":", " ")
+
+        return LLMConfig(
+            id=f"ollama.{model_name}".lower(),
+            display_name=display_name,
+            credentials="ollama",
+            provider="ollama",
+            interface="ollama",  # Ollama uses OpenAI-compatible API
+            model_id=model_name,
+        )

yera/config2/setup_handlers/openai.py

@@ -0,0 +1,137 @@
+# ruff: noqa: T201
+"""Configuration and credentials import handler for OpenAI."""
+
+import os
+import re
+
+from openai import OpenAI
+from openai.types import Model
+
+from yera.config2.dataclasses import CredentialsMap, LLMConfig, ModelRegistry
+from yera.config2.keyring import DevKeyring
+from yera.config2.setup_handlers.base import BaseProviderSetup
+
+
+class OpenAISetup(BaseProviderSetup):
+    """Setup handler for OpenAI provider credentials and models.
+
+    Manages credential detection, validation, and model fetching for the
+    OpenAI API. Supports both automatic import from environment variables
+    and interactive credential entry.
+    """
+
+    def __init__(self):
+        """Initialise the OpenAI setup handler."""
+        super().__init__("openai")
+
+    def detect_creds(self) -> dict[str, str] | None:
+        """Detect OpenAI credentials from environment variables.
+
+        Returns:
+            Dictionary with "api_key" if OPENAI_API_KEY environment variable
+            is set, otherwise None.
+        """
+        api_key = os.environ.get("OPENAI_API_KEY")
+        if api_key:
+            return {"api_key": api_key}
+        return None
+
+    def ask_for_creds(self) -> dict[str, str] | None:
+        """Prompt user to enter OpenAI API credentials interactively.
+
+        Returns:
+            Dictionary with "api_key" if user provides credentials, otherwise
+            None if user declines to enter credentials.
+        """
+        ask = self._confirm_ask_for_creds()
+        if ask:
+            print("  Please enter your OpenAI API Key:")
+            api_key = input(" > ")
+            return {"api_key": api_key}
+        return None
+
+    def validate_creds(self, creds: dict[str, str]) -> None:
+        """Validate OpenAI API key format.
+
+        Args:
+            creds: Dictionary containing "api_key" to validate.
+
+        Raises:
+            ValueError: If the API key format is invalid (wrong prefix, invalid
+                characters, appears incomplete, or is an Anthropic key).
+        """
+        api_key = creds["api_key"]
+
+        pattern = r"^sk-[A-Za-z0-9_-]+$"
+
+        if not api_key.startswith("sk-"):
+            raise ValueError(
+                "Invalid API key format. OpenAI API keys should start with 'sk-'\n"
+                "Please ensure you've copied the complete API key from the OpenAI Platform."
+            )
+
+        if api_key.startswith("sk-ant-"):
+            raise ValueError(
+                "This appears to be an Anthropic API key. OpenAI keys start with 'sk-' but not 'sk-ant-'\n"
+                "Please ensure you're using an OpenAI API key from platform.openai.com."
+            )
+
+        if not re.match(pattern, api_key):
+            raise ValueError(
+                "Invalid API key format. Key contains invalid characters.\n"
+                "Please ensure you've copied the complete API key from the OpenAI Platform."
+            )
+
+        if len(api_key) < 40:
+            raise ValueError(
+                "API key appears too short. Please ensure you've copied the complete key."
+            )
+
+    def fetch_models(self, creds_map: CredentialsMap) -> ModelRegistry:
+        """Fetch available chat models from OpenAI API.
+
+        Retrieves the list of available models and filters for just language models.
+
+        Args:
+            creds_map: Credentials map containing OpenAI provider credentials.
+
+        Returns:
+            ModelRegistry containing LLMConfig entries for all available
+            OpenAI chat models.
+        """
+        creds = {
+            k: DevKeyring.get(f"providers.{v}")
+            for k, v in creds_map.providers["openai"].items()
+        }
+
+        client = OpenAI(**creds)
+
+        # OpenAI returns all model types - filter to chat models only
+        model_list = client.models.list()
+
+        # Filter to GPT chat models and reasoning models
+        chat_models = [
+            m
+            for m in model_list.data
+            if m.id.startswith(("gpt-5", "gpt-4", "gpt-3", "o1-", "o3-"))
+        ]
+
+        def _make_model_cfg(model: Model) -> LLMConfig:
+            # OpenAI uses the model ID as display name
+            model_id = model.id.lower().replace(" ", "-").replace(".", "-")
+            return LLMConfig(
+                id=f"openai.{model_id}".lower(),
+                display_name=model.id,
+                credentials="openai",
+                provider="openai",
+                interface="openai-sdk",
+                model_id=model.id,
+            )
+
+        model_configs = [_make_model_cfg(model) for model in chat_models]
+        names = "  \n   * ".join(m.display_name for m in model_configs)
+        print(f"  Adding {len(model_configs)} LLMs from OpenAI:\n   * {names}")
+
+        return ModelRegistry(
+            llm={m.id: m for m in model_configs},
+        )

yera/config2/write.py

@@ -0,0 +1,87 @@
+"""Module for writing yera config toml."""
+
+from pathlib import Path
+from typing import Literal
+
+import tomli_w
+
+from yera.config2.dataclasses import YeraConfig
+
+
+def _dump_config_object_to_dict(obj: YeraConfig) -> dict:
+    """Un-flatten a YeraConfig object ready for serialisation.
+
+    Args:
+        obj: YeraConfig object to un-flatten
+
+    Returns:
+        Dictionary with nested model structure suitable for TOML
+
+    """
+    yera_config_dict = obj.model_dump(exclude_unset=True, exclude_none=True)
+
+    models_categories = {}
+
+    for model_type, models in yera_config_dict["models"].items():
+        nested = {}
+
+        for model_config in models.values():
+            *parts, name = model_config.pop("id").split(".")
+            head = nested
+            for part in parts:
+                if part not in head:
+                    head[part] = {}
+                head = head[part]
+            head[name] = model_config
+
+        models_categories[model_type] = nested
+
+    yera_config_dict["models"] = models_categories
+
+    return yera_config_dict
+
+
+def write_config(
+    yera_config: YeraConfig,
+    location: Literal["global", "local"],
+    exists_ok: bool,
+) -> None:
+    """Write a YeraConfig object to a yera.toml file.
+
+    Args:
+        yera_config: The configuration object to serialize and write.
+        location: Where to write the config file. 'global' writes to
+            ~/.config/yera/yera.toml, 'local' writes to ./yera.toml
+            in the current working directory.
+        exists_ok: If False, raises FileExistsError when a yera.toml
+            already exists at the target location. If True, overwrites
+            existing files.
+
+    Raises:
+        ValueError: If location is not 'global' or 'local'.
+        FileExistsError: If a yera.toml already exists at the target
+            path and exists_ok is False.
+
+    Example:
+        >>> config = YeraConfig(...)
+        >>> write_config(config, location="local", exists_ok=False)
+        # Creates ./yera.toml in current directory
+
+    """
+    if location == "global":
+        path = Path.home() / ".config" / "yera"
+    elif location == "local":
+        path = Path.cwd()
+    else:
+        raise ValueError(f"Invalid location: {location}")
+
+    path = path / "yera.toml"
+
+    if path.exists() and not exists_ok:
+        raise FileExistsError(f"A yera.toml file already exists at {path}")
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    config_dict = _dump_config_object_to_dict(yera_config)
+    toml_content = tomli_w.dumps(config_dict)
+    path.write_text(toml_content, encoding="utf-8")

yera/dsl/functions.py

@@ -0,0 +1,94 @@
+from datetime import date
+
+from yera.events import (
+    request_input_buttons,
+    request_input_date_picker,
+    request_input_slider,
+    request_input_text,
+)
+from yera.events.blocks.base.layout import _current_layout
+from yera.events.stream import await_input
+from yera.models.llm_context import llm_context
+from yera.models.llm_interfaces.base import TBaseModel
+from yera.opaque import opaque
+
+
+@opaque
+def sys_prompt(prompt: str):
+    llm = llm_context()
+    llm.add_sys_line(prompt)
+
+
+@opaque
+def chat(prompt: str, **kwargs) -> str:
+    llm = llm_context()
+    return llm.prompt_chat(prompt, **kwargs)
+
+
+@opaque
+def struct(prompt: str, cls: type[TBaseModel], **kwargs) -> TBaseModel:
+    llm = llm_context()
+    return llm.prompt_struct(prompt, cls, **kwargs)
+
+
+@opaque
+def text_input(message: str | None = None) -> str:
+    layout_ctx = _current_layout.get()
+    if layout_ctx is not None:
+        request_input_text(message)
+        layout_ctx.input_count += 1
+        layout_ctx.result_parsers.append(lambda x: x)
+        return ""
+    request_input_text(message)
+    input_event = await_input()
+    return input_event.data
+
+
+@opaque
+def buttons(options: list[str], label: str | None = None) -> str:
+    layout_ctx = _current_layout.get()
+    if layout_ctx is not None:
+        request_input_buttons(options, label)
+        layout_ctx.input_count += 1
+        layout_ctx.result_parsers.append(lambda x: x)
+        return ""
+    request_input_buttons(options, label)
+    input_event = await_input()
+    return input_event.data
+
+
+@opaque
+def date_picker(
+    label: str,
+    default_date: date | str | None = None,
+) -> date:
+    layout_ctx = _current_layout.get()
+    if layout_ctx is not None:
+        request_input_date_picker(label, default_date)
+        layout_ctx.input_count += 1
+        layout_ctx.result_parsers.append(lambda x: date.fromisoformat(x))
+        return date.today()
+    request_input_date_picker(label, default_date)
+    input_event = await_input()
+    # Parse the string date from the input event
+    date_str = input_event.data
+    return date.fromisoformat(date_str)
+
+
+@opaque
+def slider(
+    min_value: float,
+    max_value: float,
+    label: str,
+    default_value: float | None = None,
+) -> float:
+    layout_ctx = _current_layout.get()
+    if layout_ctx is not None:
+        request_input_slider(min_value, max_value, label, default_value)
+        layout_ctx.input_count += 1
+        layout_ctx.result_parsers.append(lambda x: float(x))
+        return 0.0
+    request_input_slider(min_value, max_value, label, default_value)
+    input_event = await_input()
+    # Parse the float from the input event
+    return float(input_event.data)

yera/dsl/struct.py

@@ -0,0 +1,20 @@
+from typing import Self, TypeVar
+
+from pydantic import BaseModel as PydanticBaseModel
+from pydantic import ConfigDict
+
+
+class Struct(PydanticBaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    @classmethod
+    def fill(cls, prompt: str, **kwargs) -> Self:
+        from .functions import struct
+
+        return struct(prompt, cls, **kwargs)
+
+    def __hash__(self) -> int:
+        return hash(repr(self))
+
+
+TBaseModel = TypeVar("TBaseModel", bound=Struct)

yera/dsl/workspace.py

@@ -0,0 +1,79 @@
+from typing import Any
+
+from yera.models.llm_context import llm_context
+
+
+class Workspace:
+    """Workspace for sharing data between agents within the same LLM context.
+
+    Provides dict-like API for accessing workspace variables:
+    - Use `workspace[key]` to access required keys (raises KeyError if missing)
+    - Use `workspace.get(key, default)` for optional keys (returns default if missing)
+    - Use `key in workspace` to check if a key exists
+    - Use `workspace[key] = value` or `workspace.set(key, value)` to set values
+    """
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """Get a value from workspace, returning default if key doesn't exist.
+
+        Args:
+            key: The workspace key to retrieve
+            default: Value to return if key doesn't exist (default: None)
+
+        Returns:
+            The value associated with key, or default if key doesn't exist
+        """
+        llm = llm_context()
+        return llm.workspace.variables.get(key, default)
+
+    def set(self, key: str, value: Any) -> None:
+        """Set a value in workspace.
+
+        Args:
+            key: The workspace key to set
+            value: The value to store
+        """
+        llm = llm_context()
+        llm.workspace.variables[key] = value
+
+    def __getitem__(self, key: str) -> Any:
+        """Get a value from workspace, raising KeyError if key doesn't exist.
+
+        Args:
+            key: The workspace key to retrieve
+
+        Returns:
+            The value associated with key
+
+        Raises:
+            KeyError: If the key doesn't exist in workspace
+        """
+        llm = llm_context()
+        if key not in llm.workspace.variables:
+            raise KeyError(f"Workspace key '{key}' not found")
+        return llm.workspace.variables[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        """Set a value in workspace.
+
+        Args:
+            key: The workspace key to set
+            value: The value to store
+        """
+        self.set(key, value)
+
+    def __contains__(self, key: str) -> bool:
+        """Check if a key exists in workspace.
+
+        Args:
+            key: The workspace key to check
+
+        Returns:
+            True if key exists, False otherwise
+        """
+        llm = llm_context()
+        return key in llm.workspace.variables
+
+
+workspace = Workspace()
+__all__ = ["workspace"]

yera/events/__init__.py

@@ -0,0 +1,57 @@
+"""Chat-related helpers for the Yera library.
+
+The block construction helpers defined here are also re-exported at the top
+level of the `yera` package so that they can be used either as:
+
+    import yera
+
+    yera.events.markdown(...)
+
+or:
+
+    import yera as yr
+
+    yr.markdown(...)
+"""
+
+from __future__ import annotations
+
+from yera.events.blocks import (
+    action,
+    bar_chart,
+    columns,
+    container,
+    exit_event,
+    form,
+    input_echo,
+    line_chart,
+    markdown,
+    quit_event,
+    request_input_buttons,
+    request_input_date_picker,
+    request_input_slider,
+    request_input_text,
+    spinner,
+    system_prompt,
+    table,
+)
+
+__all__ = [
+    "action",
+    "bar_chart",
+    "columns",
+    "container",
+    "exit_event",
+    "form",
+    "input_echo",
+    "line_chart",
+    "markdown",
+    "quit_event",
+    "request_input_buttons",
+    "request_input_date_picker",
+    "request_input_slider",
+    "request_input_text",
+    "spinner",
+    "system_prompt",
+    "table",
+]