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

yera/config2/setup_handlers/azure.py

@@ -0,0 +1,236 @@
+# ruff: noqa: T201
+"""Configuration and credentials import handler for Azure Foundry."""
+
+from azure.identity import DefaultAzureCredential
+from azure.mgmt.cognitiveservices import CognitiveServicesManagementClient
+from azure.mgmt.resource import SubscriptionClient
+
+from yera.config2.dataclasses import CredentialsMap, LLMConfig, ModelRegistry
+from yera.config2.keyring import DevKeyring
+from yera.config2.setup_handlers.base import BaseProviderSetup
+
+
+def _discover_azure_openai_accounts(credential: DefaultAzureCredential) -> list[dict]:
+    subscription_client = SubscriptionClient(credential)
+
+    accounts = []
+
+    for subscription in subscription_client.subscriptions.list():
+        sub_id = subscription.subscription_id
+
+        cog_client = CognitiveServicesManagementClient(credential, sub_id)
+
+        for account in cog_client.accounts.list():
+            if account.kind == "OpenAI":
+                resource_group = account.id.split("/")[4]
+
+                accounts.append(
+                    {
+                        "account_name": account.name,
+                        "endpoint": account.properties.endpoint,
+                        "subscription_id": sub_id,
+                        "resource_group": resource_group,
+                    }
+                )
+
+    return accounts
+
+
+def _list_deployments(credential: DefaultAzureCredential, account: dict) -> list[dict]:
+    client = CognitiveServicesManagementClient(credential, account["subscription_id"])
+
+    deployments = client.deployments.list(
+        resource_group_name=account["resource_group"],
+        account_name=account["account_name"],
+    )
+
+    return [
+        {
+            "name": d.name,
+            "model": d.properties.model.name,
+            "version": d.properties.model.version,
+        }
+        for d in deployments
+    ]
+
+
+def _get_api_key(credential: DefaultAzureCredential, account: dict) -> str:
+    client = CognitiveServicesManagementClient(credential, account["subscription_id"])
+
+    keys = client.accounts.list_keys(
+        resource_group_name=account["resource_group"],
+        account_name=account["account_name"],
+    )
+
+    return keys.key1
+
+
+class AzureSetup(BaseProviderSetup):
+    """Setup handler for Azure OpenAI credentials and deployments.
+
+    Manages automatic discovery and manual configuration of Azure OpenAI
+    resources. Supports automatic credential detection via Azure CLI login
+    (DefaultAzureCredential) and manual entry fallback.
+    """
+
+    def __init__(self):
+        """Initialise the Azure OpenAI setup handler."""
+        super().__init__("azure")
+
+    def detect_creds(self) -> dict[str, str] | None:
+        """Automatically detect Azure OpenAI credentials via Azure CLI.
+
+        Uses DefaultAzureCredential to authenticate and discover Azure OpenAI
+        accounts across all accessible subscriptions. Automatically retrieves
+        API keys for discovered accounts. Requires you to log in with the cli
+        beforehand.
+
+        Returns:
+            Dictionary containing account_name, endpoint, subscription_id,
+            resource_group, and api_key if a single account is found.
+            None if no accounts are found or authentication fails.
+
+        Raises:
+            RuntimeError: If multiple Azure OpenAI accounts are found.
+
+        Note:
+            Requires user to be logged in via 'az login' and have appropriate
+            permissions to list accounts and retrieve API keys.
+        """
+        credential = DefaultAzureCredential()
+        accounts = _discover_azure_openai_accounts(credential=credential)
+
+        if len(accounts) == 0:
+            return None
+
+        if len(accounts) > 1:
+            raise RuntimeError("We support just the one account for now")
+
+        account = accounts[0]
+        account["api_key"] = _get_api_key(credential=credential, account=account)
+        return account
+
+    def ask_for_creds(self) -> dict[str, str] | None:
+        """Prompt user to manually enter Azure OpenAI credentials.
+
+        Interactively requests all required Azure OpenAI configuration
+        including account name, endpoint, subscription ID, resource group,
+        and API key.
+
+        Returns:
+            Dictionary with account_name, endpoint, subscription_id,
+            resource_group, and api_key if user provides credentials.
+            None if user declines to enter credentials.
+        """
+        ask = self._confirm_ask_for_creds()
+        if not ask:
+            return None
+
+        fields = [
+            "account_name",
+            "endpoint",
+            "subscription_id",
+            "resource_group",
+            "api_key",
+        ]
+        field_list = ", ".join(fields)
+        print(f"To get everything set up we will need your Azure account {field_list}")
+        account = {}
+        for field in fields:
+            print("Please enter your " + field + ":")
+            account[field] = input(" > ")
+
+        return account
+
+    def validate_creds(self, creds: dict[str, str]) -> None:
+        """Validate Azure OpenAI credential format and completeness.
+
+        Checks that all required fields are present and validates format
+        of endpoint URL, API key length, and subscription ID structure.
+
+        Args:
+            creds: Dictionary containing Azure OpenAI credentials.
+
+        Raises:
+            ValueError: If required fields are missing, endpoint format is
+                invalid, or API key appears incomplete.
+        """
+        # Check required fields are present
+        required_fields = [
+            "account_name",
+            "endpoint",
+            "subscription_id",
+            "resource_group",
+            "api_key",
+        ]
+        missing = [f for f in required_fields if f not in creds or not creds[f]]
+
+        if missing:
+            raise ValueError(f"Missing required fields: {', '.join(missing)}")
+
+        # Validate endpoint format
+        endpoint = creds["endpoint"]
+        if not endpoint.startswith("https://"):
+            raise ValueError("Endpoint must start with 'https://'")
+
+        if not (
+            ".openai.azure.com" in endpoint
+            or ".api.cognitive.microsoft.com" in endpoint
+        ):
+            print("  Warning: Endpoint doesn't match expected Azure OpenAI format")
+
+        # Validate API key format (basic check)
+        api_key = creds["api_key"]
+        if len(api_key) < 20:
+            raise ValueError(
+                "API key appears too short. Please ensure you've copied the complete key."
+            )
+
+        # Validate subscription_id format (should be a GUID)
+        subscription_id = creds["subscription_id"]
+        if len(subscription_id) != 36 or subscription_id.count("-") != 4:
+            print("  Warning: Subscription ID doesn't look like a valid GUID")
+
+    def fetch_models(self, creds_map: CredentialsMap) -> ModelRegistry:
+        """Fetch available model deployments from Azure OpenAI account.
+
+        Uses Azure Management SDK to list all model deployments in the
+        configured Azure OpenAI account and creates LLMConfig entries
+        for each deployment.
+
+        Args:
+            creds_map: Credentials map containing Azure credential labels.
+
+        Returns:
+            ModelRegistry containing LLMConfig entries for all discovered
+            model deployments.
+
+        Note:
+            Requires DefaultAzureCredential authentication to access the
+            Azure Management API.
+        """
+        account = {
+            k: DevKeyring.get(f"providers.{v}")
+            for k, v in creds_map.providers["azure"].items()
+        }
+
+        credential = DefaultAzureCredential()
+        deployments = _list_deployments(credential, account)
+
+        def _make_model_config(d: dict) -> LLMConfig:
+            return LLMConfig(
+                id=f"azure.{d['name']}".lower(),
+                display_name=d["model"],
+                credentials="azure",
+                provider="azure",
+                interface="azure-sdk",
+                model_id=d["name"],
+            )
+
+        model_configs = [_make_model_config(d) for d in deployments]
+        names = "  \n   * ".join(m.display_name for m in model_configs)
+        print(f"  Adding {len(model_configs)} LLMs from Azure:\n   * {names}")
+
+        return ModelRegistry(
+            llm={m.id: m for m in model_configs},
+        )

yera/config2/setup_handlers/base.py

@@ -0,0 +1,125 @@
+# ruff: noqa: T201
+"""Module for the base class of provider setup handlers."""
+
+from abc import ABC, abstractmethod
+
+from yera.config2.dataclasses import (
+    CredentialsMap,
+    ModelRegistry,
+    YeraConfig,
+)
+from yera.config2.keyring import DevKeyring
+
+
+class BaseProviderSetup(ABC):
+    """Abstract base class for AI provider setup handlers.
+
+    Defines the interface for credential detection, validation, and model
+    fetching across different AI providers. Subclasses implement provider-
+    specific logic while inheriting common setup workflows.
+    """
+
+    def __init__(self, provider_name: str) -> None:
+        """Initialise the provider setup handler.
+
+        Args:
+            provider_name: Name of the provider (e.g., "anthropic", "openai").
+        """
+        self.provider_name = provider_name
+
+    def _confirm_ask_for_creds(self) -> bool:
+        print(
+            f"  Would you like to add your {self.provider_name.title()} API key? (y/n)"
+        )
+
+        choice = input(" > ")
+        while choice not in ["y", "n"]:
+            print("  Please enter either 'y' or 'n'.")
+            choice = input(" > ")
+
+        return choice == "y"
+
+    @abstractmethod
+    def detect_creds(self) -> dict[str, str] | None:
+        """Detect credentials from environment."""
+        pass
+
+    @abstractmethod
+    def ask_for_creds(self) -> dict[str, str] | None:
+        """Prompt user for credentials."""
+        pass
+
+    @abstractmethod
+    def validate_creds(self, creds: dict[str, str]) -> None:
+        """Validate credential format."""
+        pass
+
+    @abstractmethod
+    def fetch_models(self, creds_map: CredentialsMap) -> ModelRegistry:
+        """Fetch available models using provider API."""
+        pass
+
+    def automatic_setup(self) -> YeraConfig | None:
+        """Attempt automatic setup by detecting credentials from pre-existing data.
+
+        These can be environment variables and configuration files.
+
+        Returns:
+            YeraConfig with detected credentials and fetched models, or None
+            if automatic detection fails.
+        """
+        print(f"[AUTO]: Getting credentials for {self.provider_name}")
+        try:
+            creds = self.detect_creds()
+            return self._setup_and_config(creds)
+        except Exception as e:
+            print(
+                f"  An error occurred while attempting set up "
+                f"for {self.provider_name} ({type(e).__name__}: {e})"
+            )
+            print("  Skipping...")
+            return None
+
+    def interactive_setup(self) -> YeraConfig | None:
+        """Perform interactive setup by prompting user to input information.
+
+        Returns:
+            YeraConfig with user-provided credentials and fetched models, or
+            None if user declines to provide credentials.
+        """
+        try:
+            creds = self.ask_for_creds()
+            return self._setup_and_config(creds)
+        except Exception as e:
+            print(
+                f"  An error occurred while attempting to set up "
+                f"for {self.provider_name} ({type(e).__name__}: {e})"
+            )
+            print("  Skipping...")
+            return None
+
+    def _setup_and_config(self, creds: dict[str, str] | None) -> YeraConfig | None:
+        if creds is None:
+            return None
+
+        self.validate_creds(creds)
+
+        credentials_map = self._add_to_keyring_and_make_map(creds)
+        try:
+            models = self.fetch_models(credentials_map)
+        except Exception as e:
+            print(f"  Warning: Could not fetch {self.provider_name} models: {e}")
+            print("  Continuing with empty model list.")
+            models = ModelRegistry()
+
+        print(f"  Config is updated for {self.provider_name}")
+        return YeraConfig(credentials=credentials_map, models=models)
+
+    def _add_to_keyring_and_make_map(self, creds: dict[str, str]) -> CredentialsMap:
+        """Standard keyring storage (same for all providers)."""
+        for k, v in creds.items():
+            key = f"providers.{self.provider_name}.{k}"
+            print(f"  Adding {key} to dev keyring.")
+            DevKeyring.set(key, v)
+        map_dict = {k: f"{self.provider_name}.{k}" for k in creds}
+        return CredentialsMap(providers={self.provider_name: map_dict})

yera/config2/setup_handlers/llama_cpp.py

@@ -0,0 +1,205 @@
+# ruff: noqa: T201
+"""Configuration import handler for Llama-cpp."""
+
+import json
+import os
+import struct
+from pathlib import Path
+from typing import Literal
+
+import gguf
+from numpy import memmap
+from platformdirs import user_data_dir
+
+from yera.config2.dataclasses import (
+    CredentialsMap,
+    LLMConfig,
+    ModelRegistry,
+)
+from yera.config2.keyring import DevKeyring
+from yera.config2.setup_handlers.base import BaseProviderSetup
+
+
+def _decode_value(value: memmap | bytes) -> str | int:
+    if hasattr(value, "tobytes"):
+        value = value.tobytes()
+
+    if isinstance(value, bytes):
+        # Try to decode as UTF-8 string first
+        try:
+            decoded = value.decode("utf-8")
+            # If it's printable and non-empty, prefer string interpretation
+            if decoded.isprintable() and decoded.strip():
+                return decoded
+        except UnicodeDecodeError:
+            pass
+
+        # For 4-byte values that aren't valid strings, try integer unpacking
+        if len(value) == 4:
+            try:
+                return struct.unpack("<I", value)[0]
+            except struct.error:
+                pass
+
+    return "[could not decode]"
+
+
+def _get_context_length(meta: dict) -> int | str:
+    keys = [k for k in meta if k.endswith(".context_length")]
+    if len(keys) == 1:
+        return meta[keys[0]]
+    return "Unknown"
+
+
+def _find_project_root(
+    srcs: tuple[str, ...] | None = None,
+    markers: tuple[str, ...] = ("pyproject.toml", ".git"),
+) -> Path:
+    if not srcs:
+        srcs = (str(Path.cwd()),)
+
+    path = Path(srcs[0]).resolve()
+
+    for parent in [path, *path.parents]:
+        if any((parent / marker).exists() for marker in markers):
+            return parent
+
+    return path
+
+
+def _get_models_dir(
+    location: Literal["local", "global"],
+) -> Path:
+    if location == "local":
+        return _find_project_root() / "models"
+    if location == "global":
+        return Path(user_data_dir("yera")) / "models"
+    raise ValueError(f"Unknown location: {location}")
+
+
+class LlamaCppSetup(BaseProviderSetup):
+    """Setup handler for llama-cpp.
+
+    Manages finding the model directory, finding ggufs, extracting their
+    metadata and creating a catalogue json that maps IDs to local files.
+    """
+
+    def __init__(self):
+        """Initialise the LlamaCpp setup handler."""
+        super().__init__("llama-cpp")
+
+    def detect_creds(self) -> dict[str, str] | None:
+        """Detect LlamaCpp models directory.
+
+        The priority is
+            1. YERA_MODELS_DIR env variable
+            2. ./models
+            3. ~/.local/yera/models
+
+        Returns:
+            Dictionary containing the model directory path, otherwise
+            None if no model directory is found,
+
+        """
+        # 1. Check environment variable first
+        if env_dir := os.getenv("YERA_MODEL_DIR"):
+            return {"models_dir": env_dir}
+
+        # 2. Try local project directory
+        local_dir = _get_models_dir("local")
+        if local_dir.exists():
+            return {"models_dir": str(local_dir)}
+
+        # 3. Fall back to global user directory
+        global_dir = _get_models_dir("global")
+        return {"models_dir": str(global_dir)}
+
+    def ask_for_creds(self) -> dict[str, str] | None:
+        """Prompt the user to enter their models directory manually.
+
+        Returns:
+            Dictionary containing the model directory path, otherwise
+            None if user enters an invalid path.
+
+        """
+        print("Please enter the path to your models directory.")
+        models_dir = Path(input(" > "))
+        return {"models_dir": str(models_dir)}
+
+    def validate_creds(self, creds: dict[str, str]) -> None:
+        """Validate the path to the models directory.
+
+        Args:
+            creds: Dictionary containing the model directory path.
+
+        Raises:
+            FileNotFoundError: Raised if the path does not exist.
+
+        """
+        models_dir = Path(creds["models_dir"])
+        if not models_dir.exists():
+            raise FileNotFoundError(models_dir)
+
+    def _make_model_cfg(self, model: dict[str, str]) -> LLMConfig:
+        provider = model.get("organization", "unknown")
+        gguf_path = Path(model["gguf_path"])
+
+        model_id = gguf_path.stem.replace(".", "p")
+        return LLMConfig(
+            id=f"llamacpp.{provider}.{model_id}".lower(),
+            display_name=model["name"],
+            credentials=self.provider_name,
+            provider=provider,
+            interface="llama-cpp",
+            model_id=model_id,
+        )
+
+    def fetch_models(self, creds_map: CredentialsMap) -> ModelRegistry:
+        """Fetch information from ggufs in models directory and build registry.
+
+        Args:
+            creds_map: Dictionary containing the model directory path.
+
+        Returns:
+            ModelRegistry containing configurations for all the models in the
+            models directory.
+
+        """
+        creds = {
+            k: DevKeyring.get(f"providers.{v}")
+            for k, v in creds_map.providers[self.provider_name].items()
+        }
+
+        models_dir = Path(creds["models_dir"])
+
+        catalogue = {}
+
+        model_configs = []
+        for gguf_path in list(models_dir.rglob("*.gguf")):
+            reader = gguf.GGUFReader(gguf_path)
+
+            data = {"gguf_path": str(gguf_path)}
+            other = {}
+
+            for k, v in reader.fields.items():
+                val = v.parts[v.data[0]]
+                if k.startswith("general."):
+                    data[v.name[8:]] = _decode_value(val)
+                else:
+                    other[v.name] = _decode_value(val)
+
+            data["quant"] = gguf_path.stem.split("-")[-1]
+            data["context_length"] = _get_context_length(other)
+
+            model_cfg = self._make_model_cfg(data)
+            catalogue[model_cfg.id] = str(gguf_path)
+            model_configs.append(model_cfg)
+
+        (models_dir / "catalogue.json").write_text(json.dumps(catalogue, indent=2))
+
+        names = "  \n   * ".join(m.display_name for m in model_configs)
+        print(f"  Adding {len(model_configs)} LLMs from {models_dir}:\n   * {names}")
+
+        return ModelRegistry(
+            llm={m.id: m for m in model_configs},
+        )