| from __future__ import annotations |
|
|
| from dataclasses import dataclass |
| from pathlib import Path |
| from typing import Any |
|
|
| import yaml |
|
|
|
|
| @dataclass(frozen=True) |
| class ModelInfo: |
| """Configured model metadata.""" |
|
|
| config_id: str |
| hf_id: str |
| display_name: str |
| type: str |
| parameters_b: float |
| backend: str |
| context_length: int |
| notes: str |
| thinking_mode: bool |
| gguf: dict[str, Any] |
| backend_capabilities: dict[str, list[str]] |
| trust_remote_code: bool |
|
|
|
|
| def load_model_catalog(path: str) -> dict[str, ModelInfo]: |
| raw = yaml.safe_load(Path(path).read_text(encoding="utf-8")) |
| catalog = {} |
| for config_id, cfg in raw.get("models", {}).items(): |
| catalog[config_id] = ModelInfo( |
| config_id=config_id, |
| hf_id=cfg["hf_id"], |
| display_name=cfg.get("display_name", config_id), |
| type=cfg.get("type", "text"), |
| parameters_b=float(cfg.get("parameters_b", 0)), |
| backend=cfg.get("backend", "placeholder"), |
| context_length=int(cfg.get("context_length", 0)), |
| notes=cfg.get("notes", ""), |
| thinking_mode=bool(cfg.get("thinking_mode", False)), |
| gguf=cfg.get("gguf", {}), |
| backend_capabilities={ |
| backend: list(capabilities) |
| for backend, capabilities in cfg.get("backend_capabilities", {}).items() |
| }, |
| trust_remote_code=bool(cfg.get("trust_remote_code", False)), |
| ) |
| return catalog |
|
|
|
|
| def model_choices(catalog: dict[str, ModelInfo], model_type: str | None = None) -> list[str]: |
| choices = [] |
| for model in catalog.values(): |
| if model_type and model.type != model_type: |
| continue |
| choices.append(model.config_id) |
| return choices |
|
|
|
|
| def model_summary(model: ModelInfo) -> dict[str, Any]: |
| return { |
| "config_id": model.config_id, |
| "hf_id": model.hf_id, |
| "display_name": model.display_name, |
| "type": model.type, |
| "parameters_b": model.parameters_b, |
| "backend": model.backend, |
| "context_length": model.context_length, |
| "thinking_mode": model.thinking_mode, |
| "gguf": model.gguf, |
| "backend_capabilities": model.backend_capabilities, |
| "trust_remote_code": model.trust_remote_code, |
| "notes": model.notes, |
| } |
|
|
|
|
| def validate_catalog(catalog: dict[str, ModelInfo], max_parameters_b: float = 32) -> list[str]: |
| warnings = [] |
| for model in catalog.values(): |
| if model.parameters_b > max_parameters_b: |
| warnings.append( |
| f"{model.config_id} has {model.parameters_b}B parameters, " |
| f"above the {max_parameters_b}B limit." |
| ) |
| if model.backend == "placeholder": |
| warnings.append( |
| f"{model.config_id} uses placeholder backend; real inference is not wired yet." |
| ) |
| if model.backend not in model.backend_capabilities: |
| warnings.append( |
| f"{model.config_id} has no capability metadata for backend {model.backend}." |
| ) |
| if not model.hf_id: |
| warnings.append(f"{model.config_id} is missing hf_id.") |
| return warnings |
|
|
