131 lines
5.0 KiB
Python
131 lines
5.0 KiB
Python
"""Test-only seams. Nothing in the production code path may import this module.
|
|
|
|
Startup admits a node only on a capability report produced by a *real* forward
|
|
through the loaded shard (see :mod:`meshnet_node.admission`). Tests run against
|
|
fake or stub backends that cannot perform one, so they pass an explicit validator
|
|
from here instead — the honest statement being "this test asserts capability it
|
|
never proved", which is a thing a test may do and a node may not.
|
|
|
|
`capability_stub` builds the deliberately-wrong reports the fail-closed tests
|
|
need: a failed one, one for another model or shard, one that has aged out.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import time
|
|
from typing import Any
|
|
|
|
from .admission import CapabilityContext, CapabilityValidator
|
|
from . import __version__ as _PACKAGE_VERSION
|
|
from .capability import STATUS_PASSED, CapabilityReport, build_capability_report
|
|
from .gguf_ownership import authoritative_dense_llama_ownership
|
|
from .runtime_recipe import build_runtime_recipe_identity
|
|
|
|
|
|
def capability_report_for(
|
|
context: CapabilityContext,
|
|
*,
|
|
status: str = STATUS_PASSED,
|
|
model_id: str | None = None,
|
|
shard_start: int | None = None,
|
|
shard_end: int | None = None,
|
|
recipe_id: str | None = None,
|
|
recipe_version: str | None = None,
|
|
backend_id: str | None = None,
|
|
device: str | None = None,
|
|
artifact_hash: str | None = None,
|
|
activation_dtype: str | None = None,
|
|
compute_dtype: str | None = None,
|
|
kv_dtype: str | None = None,
|
|
kv_layout: str | None = None,
|
|
tokenizer_revision: str | None = None,
|
|
architecture_adapter: str | None = None,
|
|
boundary_schema_version: int = 1,
|
|
cache_layout: str | None = None,
|
|
validated_at: float | None = None,
|
|
age_seconds: float = 0.0,
|
|
diagnostics: Any = None,
|
|
duration_ms: int = 0,
|
|
) -> CapabilityReport:
|
|
"""A report describing `context`, with any field bent away from the truth."""
|
|
now = time.time() if validated_at is None else validated_at
|
|
backend = getattr(context, "backend", None)
|
|
model_config = getattr(getattr(backend, "model", None), "config", None)
|
|
model_config_payload = (
|
|
model_config.to_dict() if hasattr(model_config, "to_dict") else model_config
|
|
)
|
|
resolved_cache_layout = (
|
|
"stateless"
|
|
if getattr(backend, "supports_kv_cache", False) is False
|
|
else "local-hot-kv"
|
|
)
|
|
ownership = authoritative_dense_llama_ownership(backend, context.selection)
|
|
runtime_recipe = build_runtime_recipe_identity(
|
|
model_id=context.selection.model_id,
|
|
revision=getattr(getattr(backend, "model", None), "revision", None),
|
|
model_config=model_config_payload,
|
|
recipe_params=context.recipe.params,
|
|
weight_quantization=context.selection.quantization,
|
|
backend_id=context.recipe.backend_id,
|
|
runtime_version=_PACKAGE_VERSION,
|
|
activation_dtype=activation_dtype,
|
|
compute_dtype=compute_dtype,
|
|
kv_dtype=kv_dtype,
|
|
kv_layout=kv_layout or _backend_kv_layout(backend),
|
|
tokenizer_revision=tokenizer_revision,
|
|
architecture_adapter=architecture_adapter,
|
|
boundary_schema_version=boundary_schema_version,
|
|
cache_layout=cache_layout or resolved_cache_layout,
|
|
)
|
|
return build_capability_report(
|
|
model_id=model_id or context.selection.model_id,
|
|
shard_start=ownership.start_layer if shard_start is None else shard_start,
|
|
shard_end=ownership.end_layer if shard_end is None else shard_end,
|
|
recipe_id=recipe_id or context.recipe.id,
|
|
recipe_version=recipe_version or context.recipe.version,
|
|
catalogue_version=context.manifest.catalogue_version,
|
|
backend_id=backend_id or context.recipe.backend_id,
|
|
device=device or context.device,
|
|
quantization=context.selection.quantization,
|
|
runtime=_runtime_versions(),
|
|
artifact_hash=artifact_hash,
|
|
runtime_recipe=runtime_recipe,
|
|
owns_embedding=ownership.owns_embedding,
|
|
owns_final_head=ownership.owns_final_head,
|
|
status=status,
|
|
duration_ms=duration_ms,
|
|
diagnostics=diagnostics,
|
|
validated_at=now - age_seconds,
|
|
)
|
|
|
|
|
|
def assume_capability(context: CapabilityContext) -> CapabilityReport:
|
|
"""Assert the selection works, without proving it. Tests only."""
|
|
return capability_report_for(context)
|
|
|
|
|
|
def capability_stub(**overrides: Any) -> CapabilityValidator:
|
|
"""A validator producing a report that deviates from `context` as named."""
|
|
|
|
def validator(context: CapabilityContext) -> CapabilityReport:
|
|
return capability_report_for(context, **overrides)
|
|
|
|
return validator
|
|
|
|
|
|
def _runtime_versions() -> dict[str, str]:
|
|
versions: dict[str, str] = {}
|
|
for name in ("torch", "transformers"):
|
|
try:
|
|
module = __import__(name)
|
|
except Exception:
|
|
continue
|
|
version = getattr(module, "__version__", None)
|
|
if version:
|
|
versions[name] = str(version)
|
|
return versions
|
|
|
|
|
|
def _backend_kv_layout(backend: Any) -> str:
|
|
return "session-cache" if getattr(backend, "supports_kv_cache", False) else "stateless"
|