Spaces:
Running
Running
| """Engine compatibility matrix loader + match function.""" | |
| from __future__ import annotations | |
| from functools import lru_cache | |
| from importlib.resources import files | |
| from pathlib import Path | |
| from typing import Literal | |
| from packaging.specifiers import InvalidSpecifier, SpecifierSet | |
| from packaging.version import InvalidVersion, Version | |
| from pydantic import BaseModel, Field | |
| from llm_cal.common.yaml_loader import load_yaml | |
| SupportLevel = Literal["full", "partial", "broken", "unverified"] | |
| VerificationLevel = Literal["verified", "cited", "unverified"] | |
| class EngineFlag(BaseModel): | |
| flag: str | |
| value: str | None = None | |
| note_en: str | None = None | |
| note_zh: str | None = None | |
| class EngineSource(BaseModel): | |
| type: str # release_notes | announcement | pr | tested | |
| url: str | None = None | |
| captured_date: str | None = None | |
| note_en: str | None = None | |
| note_zh: str | None = None | |
| # `tested` specific fields (may be absent on other types) | |
| tester: str | None = None | |
| date: str | None = None | |
| hardware: str | None = None | |
| class EngineCompatEntry(BaseModel): | |
| engine: Literal["vllm", "sglang"] | |
| version_spec: str # e.g. ">=0.19.0" | |
| matches_model_type: str | |
| support: SupportLevel | |
| verification_level: VerificationLevel | |
| required_flags: list[EngineFlag] = Field(default_factory=list) | |
| optional_flags: list[EngineFlag] = Field(default_factory=list) | |
| sources: list[EngineSource] = Field(default_factory=list) | |
| caveats_en: list[str] = Field(default_factory=list) | |
| caveats_zh: list[str] = Field(default_factory=list) | |
| class EngineCompatMatrix(BaseModel): | |
| schema_version: int | |
| entries: list[EngineCompatEntry] | |
| def _default_path() -> Path: | |
| return Path(str(files("llm_cal.engine_compat").joinpath("matrix.yaml"))) | |
| def load_matrix(path: Path | None = None) -> EngineCompatMatrix: | |
| return load_yaml(path or _default_path(), EngineCompatMatrix) | |
| def find_match( | |
| engine: str, | |
| model_type: str, | |
| version: str | None = None, | |
| matrix: EngineCompatMatrix | None = None, | |
| ) -> EngineCompatEntry | None: | |
| """Find the highest-version matching entry for (engine, model_type). | |
| If `version` is None, we return the broadest entry (any version matching | |
| model_type on the given engine). If `version` is given, we filter to entries | |
| whose version_spec covers it. | |
| """ | |
| m = matrix or load_matrix() | |
| engine_norm = engine.lower().strip() | |
| model_type_norm = model_type.lower().strip() | |
| candidates = [ | |
| e for e in m.entries if e.engine == engine_norm and e.matches_model_type == model_type_norm | |
| ] | |
| if not candidates: | |
| return None | |
| if version is None: | |
| # Return the entry with the "highest lower bound" as the most relevant | |
| return max(candidates, key=_lower_bound_key) | |
| try: | |
| v = Version(version) | |
| except InvalidVersion: | |
| return candidates[0] | |
| for entry in candidates: | |
| try: | |
| if v in SpecifierSet(entry.version_spec): | |
| return entry | |
| except InvalidSpecifier: | |
| continue | |
| return None | |
| def _lower_bound_key(entry: EngineCompatEntry) -> Version: | |
| """Extract the lowest version a spec matches (approximate, used only for sort).""" | |
| try: | |
| spec = SpecifierSet(entry.version_spec) | |
| except InvalidSpecifier: | |
| return Version("0.0.0") | |
| for single in spec: | |
| if single.operator in (">=", "==", ">"): | |
| try: | |
| return Version(single.version) | |
| except InvalidVersion: | |
| continue | |
| return Version("0.0.0") | |