| from __future__ import annotations |
|
|
| from dataclasses import asdict, dataclass, field |
| from typing import Any |
|
|
| from adam.model_plugins import ModelPlugin, ModelPluginRegistry |
|
|
|
|
| @dataclass(frozen=True, slots=True) |
| class ModelProfile: |
| """Normalized model profile built from ADAM's plugin manifests.""" |
|
|
| id: str |
| name: str |
| category: str |
| architecture: str |
| version: str |
| description: str |
| status: str = "experimental" |
| output_type: str = "image" |
| training: dict[str, dict[str, Any]] = field(default_factory=dict) |
| generation: dict[str, dict[str, Any]] = field(default_factory=dict) |
| trainer_module: str = "" |
| generator_module: str = "" |
| trainer_tool: str = "" |
| generator_tool: str = "" |
| capabilities: list[str] = field(default_factory=list) |
| hardware: dict[str, Any] = field(default_factory=dict) |
| vram_behavior: dict[str, Any] = field(default_factory=dict) |
| input_formats: list[str] = field(default_factory=list) |
| output_formats: list[str] = field(default_factory=list) |
|
|
| def to_dict(self) -> dict[str, Any]: |
| return asdict(self) |
|
|
|
|
| def profile_from_plugin(plugin: ModelPlugin) -> ModelProfile: |
| info = dict(plugin.info) |
| training_tool = dict(plugin.training_tool) |
| generation_tool = dict(plugin.generation_tool) |
| capabilities = list( |
| dict.fromkeys( |
| [ |
| *info.get("capabilities", []), |
| *training_tool.get("capabilities", []), |
| *generation_tool.get("capabilities", []), |
| ] |
| ) |
| ) |
| trainer_backend = dict(training_tool.get("backend", {})) |
| generator_backend = dict(generation_tool.get("backend", {})) |
| return ModelProfile( |
| id=plugin.id, |
| name=str(info.get("name", plugin.name)), |
| category=str(info.get("category", "")), |
| architecture=str(info.get("architecture", plugin.id)), |
| version=str(info.get("version", "")), |
| description=str(info.get("description", "")), |
| status=str(info.get("status", "experimental")), |
| output_type=str(info.get("output_type", "image")), |
| training=plugin.training_settings, |
| generation=plugin.generation_settings, |
| trainer_module=str(trainer_backend.get("module", "")), |
| generator_module=str(generator_backend.get("module", "")), |
| trainer_tool=plugin.trainer_id if plugin.training_settings else "", |
| generator_tool=plugin.generator_id if plugin.generation_settings else "", |
| capabilities=capabilities, |
| hardware=dict(info.get("hardware", {})), |
| vram_behavior=dict(info.get("vram_behavior", {})), |
| input_formats=list(info.get("input_formats", [])), |
| output_formats=list(info.get("output_formats", [])), |
| ) |
|
|
|
|
| class ModelProfileRegistry: |
| """Read-only view over plugin manifests for UI and automation features.""" |
|
|
| def __init__(self, plugins: ModelPluginRegistry) -> None: |
| self.plugins = plugins |
|
|
| def all(self) -> list[ModelProfile]: |
| return [ |
| profile_from_plugin(plugin) |
| for plugin in self.plugins.all() |
| if plugin.info.get("category") != "Template" |
| ] |
|
|
| def get(self, profile_id: str) -> ModelProfile | None: |
| plugin = self.plugins.by_trainer(profile_id) |
| return profile_from_plugin(plugin) if plugin else None |
|
|
| def as_catalog(self) -> list[dict[str, Any]]: |
| return [profile.to_dict() for profile in self.all()] |
|
|
