solverpilot 0.1__py3-none-any.whl

solverpilot/extensions/manifest.py

@@ -0,0 +1,232 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+import hashlib
+import json
+import math
+import re
+from types import MappingProxyType
+from typing import Any, Mapping
+
+from .errors import ExtensionManifestError
+from .versioning import SemanticVersion
+
+_ID_RE = re.compile(r"^[a-z][a-z0-9_.-]{2,127}$")
+_TOKEN_RE = re.compile(r"^[a-z][a-z0-9_.-]{0,127}$")
+_ENTRYPOINT_RE = re.compile(
+    r"^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*:"
+    r"[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*$"
+)
+_DEP_RE = re.compile(r"^([a-z][a-z0-9_.-]{2,127})(.*)$")
+
+
+class ExtensionKind(str, Enum):
+    BACKEND = "backend"
+    BRIDGE = "bridge"
+    DATA_CONNECTOR = "data_connector"
+    FEATURE_EXTRACTOR = "feature_extractor"
+    EVALUATOR = "evaluator"
+    REPORTER = "reporter"
+    APPLICATION = "application"
+    MIXED = "mixed"
+
+
+class ExtensionLifecycle(str, Enum):
+    EXPERIMENTAL = "experimental"
+    ACTIVE = "active"
+    DEPRECATED = "deprecated"
+
+
+def _kind(value: ExtensionKind | str) -> ExtensionKind:
+    if isinstance(value, ExtensionKind):
+        return value
+    try:
+        return ExtensionKind(str(value).strip().lower())
+    except ValueError as exc:
+        raise ExtensionManifestError(f"unsupported extension kind {value!r}") from exc
+
+
+def _lifecycle(value: ExtensionLifecycle | str) -> ExtensionLifecycle:
+    if isinstance(value, ExtensionLifecycle):
+        return value
+    try:
+        return ExtensionLifecycle(str(value).strip().lower())
+    except ValueError as exc:
+        raise ExtensionManifestError(f"unsupported extension lifecycle {value!r}") from exc
+
+
+def _token(value: object, *, field_name: str) -> str:
+    item = str(value).strip().lower()
+    if not _TOKEN_RE.fullmatch(item):
+        raise ExtensionManifestError(f"invalid {field_name} token {value!r}")
+    return item
+
+
+def _freeze_json(
+    value: Any,
+    *,
+    field_name: str,
+    _seen: set[int] | None = None,
+    _depth: int = 0,
+) -> Any:
+    if _depth > 64:
+        raise ExtensionManifestError(f"{field_name} nesting exceeds the supported depth")
+    if value is None or isinstance(value, (str, bool, int)):
+        return value
+    if isinstance(value, float):
+        if not math.isfinite(value):
+            raise ExtensionManifestError(f"{field_name} may not contain NaN or Infinity")
+        return value
+    if isinstance(value, (Mapping, list, tuple)):
+        seen = set() if _seen is None else _seen
+        marker = id(value)
+        if marker in seen:
+            raise ExtensionManifestError(f"{field_name} may not contain cyclic data")
+        seen.add(marker)
+        try:
+            if isinstance(value, Mapping):
+                frozen: dict[str, Any] = {}
+                for key, item in value.items():
+                    if not isinstance(key, str):
+                        raise ExtensionManifestError(f"{field_name} mapping keys must be strings")
+                    frozen[key] = _freeze_json(
+                        item, field_name=field_name, _seen=seen, _depth=_depth + 1
+                    )
+                return MappingProxyType(frozen)
+            return tuple(
+                _freeze_json(item, field_name=field_name, _seen=seen, _depth=_depth + 1)
+                for item in value
+            )
+        finally:
+            seen.remove(marker)
+    raise ExtensionManifestError(
+        f"{field_name} must be finite JSON-compatible data, not {type(value).__name__}"
+    )
+
+
+def _thaw_json(value: Any) -> Any:
+    if isinstance(value, Mapping):
+        return {str(key): _thaw_json(item) for key, item in value.items()}
+    if isinstance(value, tuple):
+        return [_thaw_json(item) for item in value]
+    return value
+
+
+@dataclass(frozen=True, slots=True)
+class ExtensionDependency:
+    extension_id: str
+    version: str = "*"
+
+    def __post_init__(self) -> None:
+        extension_id = str(self.extension_id).strip().lower()
+        if not _ID_RE.fullmatch(extension_id):
+            raise ExtensionManifestError(f"invalid dependency extension_id {self.extension_id!r}")
+        spec = str(self.version).strip() or "*"
+        # Validate every referenced version eagerly.
+        if spec != "*":
+            from .versioning import version_satisfies
+
+            # A version that satisfies itself is not required; this call is only syntax validation.
+            # Use a harmless concrete version and tolerate False, but propagate malformed syntax.
+            version_satisfies("0.0.0", spec)
+        object.__setattr__(self, "extension_id", extension_id)
+        object.__setattr__(self, "version", spec)
+
+    @classmethod
+    def parse(cls, value: "ExtensionDependency | str") -> "ExtensionDependency":
+        if isinstance(value, cls):
+            return value
+        raw = str(value).strip()
+        match = _DEP_RE.fullmatch(raw)
+        if match is None:
+            raise ExtensionManifestError(f"invalid dependency declaration {value!r}")
+        extension_id = match.group(1)
+        spec = match.group(2).strip() or "*"
+        return cls(extension_id=extension_id, version=spec)
+
+    def to_dict(self) -> dict[str, str]:
+        return {"extension_id": self.extension_id, "version": self.version}
+
+
+@dataclass(frozen=True, slots=True)
+class ExtensionManifest:
+    """Immutable, content-addressed description of a trusted SolverPilot extension."""
+
+    extension_id: str
+    name: str
+    version: str
+    kind: ExtensionKind | str
+    description: str
+    capabilities: tuple[str, ...] = ()
+    dependencies: tuple[ExtensionDependency | str, ...] = ()
+    entrypoint: str | None = None
+    lifecycle: ExtensionLifecycle | str = ExtensionLifecycle.EXPERIMENTAL
+    metadata: Mapping[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        extension_id = str(self.extension_id).strip().lower()
+        if not _ID_RE.fullmatch(extension_id):
+            raise ExtensionManifestError(
+                "extension_id must start with a lowercase letter, be 3-128 characters, "
+                "and contain only lowercase letters, digits, '.', '_' or '-'"
+            )
+        name = str(self.name).strip()
+        description = str(self.description).strip()
+        if not name:
+            raise ExtensionManifestError("name must be non-empty")
+        if not description:
+            raise ExtensionManifestError("description must be non-empty")
+        version = str(self.version).strip()
+        SemanticVersion.parse(version)
+        capabilities: list[str] = []
+        for value in self.capabilities:
+            item = _token(value, field_name="capability")
+            if item not in capabilities:
+                capabilities.append(item)
+        dependencies: list[ExtensionDependency] = []
+        seen: set[str] = set()
+        for value in self.dependencies:
+            dep = ExtensionDependency.parse(value)
+            if dep.extension_id == extension_id:
+                raise ExtensionManifestError("an extension may not depend on itself")
+            if dep.extension_id in seen:
+                raise ExtensionManifestError(f"duplicate dependency {dep.extension_id!r}")
+            seen.add(dep.extension_id)
+            dependencies.append(dep)
+        entrypoint = None if self.entrypoint is None else str(self.entrypoint).strip()
+        if entrypoint == "":
+            entrypoint = None
+        if entrypoint is not None and not _ENTRYPOINT_RE.fullmatch(entrypoint):
+            raise ExtensionManifestError("entrypoint must use the form 'package.module:Attribute'")
+        object.__setattr__(self, "extension_id", extension_id)
+        object.__setattr__(self, "name", name)
+        object.__setattr__(self, "version", version)
+        object.__setattr__(self, "kind", _kind(self.kind))
+        object.__setattr__(self, "description", description)
+        object.__setattr__(self, "capabilities", tuple(capabilities))
+        object.__setattr__(self, "dependencies", tuple(dependencies))
+        object.__setattr__(self, "entrypoint", entrypoint)
+        object.__setattr__(self, "lifecycle", _lifecycle(self.lifecycle))
+        object.__setattr__(self, "metadata", _freeze_json(self.metadata, field_name="metadata"))
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "extension_id": self.extension_id,
+            "name": self.name,
+            "version": self.version,
+            "kind": self.kind.value,
+            "description": self.description,
+            "capabilities": list(self.capabilities),
+            "dependencies": [dep.to_dict() for dep in self.dependencies],
+            "entrypoint": self.entrypoint,
+            "lifecycle": self.lifecycle.value,
+            "metadata": _thaw_json(self.metadata),
+        }
+
+    @property
+    def sha256(self) -> str:
+        raw = json.dumps(
+            self.to_dict(), sort_keys=True, separators=(",", ":"), ensure_ascii=True, allow_nan=False
+        ).encode("utf-8")
+        return hashlib.sha256(raw).hexdigest()

solverpilot/extensions/model.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+import re
+from typing import Any, Protocol, runtime_checkable
+
+from solverpilot.backends.base import Backend
+from solverpilot.bridges.registry import BridgeSpec
+
+from .errors import ExtensionManifestError
+from .manifest import ExtensionManifest
+
+_NAME_RE = re.compile(r"^[a-z][a-z0-9_.-]{0,127}$")
+
+
+@dataclass(frozen=True, slots=True)
+class ExtensionSelfCheck:
+    ok: bool
+    checks: tuple[str, ...] = ()
+    warnings: tuple[str, ...] = ()
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.ok, bool):
+            raise ExtensionManifestError("self-check ok must be a boolean")
+        checks = tuple(str(item).strip() for item in self.checks)
+        warnings = tuple(str(item).strip() for item in self.warnings)
+        if any(not item for item in checks):
+            raise ExtensionManifestError("self-check identifiers must be non-empty")
+        if any(not item for item in warnings):
+            raise ExtensionManifestError("self-check warnings must be non-empty")
+        object.__setattr__(self, "checks", checks)
+        object.__setattr__(self, "warnings", warnings)
+
+
+class ExportKind(str, Enum):
+    DATA_CONNECTOR = "data_connector"
+    FEATURE_EXTRACTOR = "feature_extractor"
+    EVALUATOR = "evaluator"
+    REPORTER = "reporter"
+    APPLICATION = "application"
+
+
+@dataclass(frozen=True, slots=True)
+class NamedExtensionExport:
+    kind: ExportKind | str
+    name: str
+    value: Any
+
+    def __post_init__(self) -> None:
+        try:
+            kind = self.kind if isinstance(self.kind, ExportKind) else ExportKind(str(self.kind).strip().lower())
+        except ValueError as exc:
+            raise ExtensionManifestError(f"unsupported export kind {self.kind!r}") from exc
+        name = str(self.name).strip().lower()
+        if not _NAME_RE.fullmatch(name):
+            raise ExtensionManifestError(f"invalid export name {self.name!r}")
+        if self.value is None:
+            raise ExtensionManifestError("export value may not be None")
+        object.__setattr__(self, "kind", kind)
+        object.__setattr__(self, "name", name)
+
+    @property
+    def key(self) -> str:
+        return f"{self.kind.value}:{self.name}"
+
+
+@dataclass(frozen=True, slots=True)
+class ExtensionContributions:
+    backends: tuple[Backend, ...] = ()
+    bridges: tuple[BridgeSpec, ...] = ()
+    exports: tuple[NamedExtensionExport, ...] = ()
+
+
+@runtime_checkable
+class Extension(Protocol):
+    @property
+    def manifest(self) -> ExtensionManifest: ...
+
+    def self_check(self) -> ExtensionSelfCheck: ...
+
+    def contributions(self) -> ExtensionContributions: ...
+
+
+@dataclass(frozen=True, slots=True)
+class StagedExtensionContribution:
+    extension_id: str
+    extension_version: str
+    backends: tuple[Backend, ...] = ()
+    bridges: tuple[BridgeSpec, ...] = ()
+    exports: tuple[NamedExtensionExport, ...] = ()
+
+
+@dataclass(frozen=True, slots=True)
+class ExtensionActivationPlan:
+    generation: int
+    extension_order: tuple[str, ...]
+    staged: tuple[StagedExtensionContribution, ...]
+    target_backend_names: tuple[str, ...]
+    target_bridge_keys: tuple[str, ...]
+    plan_sha256: str

solverpilot/extensions/versioning.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import re
+
+from .errors import ExtensionManifestError
+
+_SEMVER_RE = re.compile(
+    r"^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)"
+    r"(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?"
+    r"(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$"
+)
+_COMPARATOR_RE = re.compile(r"^(==|!=|>=|<=|>|<|\^|~)?\s*(.+)$")
+
+
+def _identifier_key(identifier: str) -> tuple[int, int | str]:
+    if identifier.isdigit():
+        return (0, int(identifier))
+    return (1, identifier)
+
+
+@dataclass(frozen=True, slots=True)
+class SemanticVersion:
+    major: int
+    minor: int
+    patch: int
+    prerelease: tuple[str, ...] = ()
+    build: tuple[str, ...] = ()
+
+    @classmethod
+    def parse(cls, value: str) -> "SemanticVersion":
+        raw = str(value).strip()
+        match = _SEMVER_RE.fullmatch(raw)
+        if match is None:
+            raise ExtensionManifestError(
+                f"version {value!r} must be valid SemVer MAJOR.MINOR.PATCH with optional prerelease/build suffix"
+            )
+        pre = tuple(match.group(4).split(".")) if match.group(4) else ()
+        build = tuple(match.group(5).split(".")) if match.group(5) else ()
+        for ident in pre:
+            if ident.isdigit() and len(ident) > 1 and ident.startswith("0"):
+                raise ExtensionManifestError(f"invalid numeric prerelease identifier {ident!r}")
+        return cls(int(match.group(1)), int(match.group(2)), int(match.group(3)), pre, build)
+
+    def _precedence(self) -> tuple[object, ...]:
+        base: tuple[object, ...] = (self.major, self.minor, self.patch)
+        if not self.prerelease:
+            return base + ((2, ""),)
+        return base + ((1, tuple(_identifier_key(x) for x in self.prerelease)),)
+
+    def __lt__(self, other: "SemanticVersion") -> bool:
+        return self._precedence() < other._precedence()
+
+    def __le__(self, other: "SemanticVersion") -> bool:
+        return self == other or self < other
+
+    def __gt__(self, other: "SemanticVersion") -> bool:
+        return not self <= other
+
+    def __ge__(self, other: "SemanticVersion") -> bool:
+        return not self < other
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, SemanticVersion):
+            return NotImplemented
+        return (
+            self.major,
+            self.minor,
+            self.patch,
+            self.prerelease,
+        ) == (
+            other.major,
+            other.minor,
+            other.patch,
+            other.prerelease,
+        )
+
+    def __str__(self) -> str:
+        text = f"{self.major}.{self.minor}.{self.patch}"
+        if self.prerelease:
+            text += "-" + ".".join(self.prerelease)
+        if self.build:
+            text += "+" + ".".join(self.build)
+        return text
+
+
+def _caret_upper(v: SemanticVersion) -> SemanticVersion:
+    if v.major > 0:
+        return SemanticVersion(v.major + 1, 0, 0)
+    if v.minor > 0:
+        return SemanticVersion(0, v.minor + 1, 0)
+    return SemanticVersion(0, 0, v.patch + 1)
+
+
+def _tilde_upper(v: SemanticVersion) -> SemanticVersion:
+    return SemanticVersion(v.major, v.minor + 1, 0)
+
+
+def version_satisfies(version: str, specifier: str) -> bool:
+    """Return whether *version* satisfies a small deterministic SemVer constraint language.
+
+    Supported clauses are comma-separated ``== != >= <= > < ^ ~`` comparisons. An empty
+    specifier accepts every valid version. Build metadata does not affect precedence.
+    """
+
+    current = SemanticVersion.parse(version)
+    raw = str(specifier).strip()
+    if not raw or raw == "*":
+        return True
+    parts = raw.split(",")
+    if any(not part.strip() for part in parts):
+        raise ExtensionManifestError(f"invalid version constraint {specifier!r}")
+    clauses = [part.strip() for part in parts]
+    for clause in clauses:
+        match = _COMPARATOR_RE.fullmatch(clause)
+        if match is None:
+            raise ExtensionManifestError(f"invalid version constraint {clause!r}")
+        op = match.group(1) or "=="
+        target = SemanticVersion.parse(match.group(2))
+        if op == "==" and not current == target:
+            return False
+        if op == "!=" and current == target:
+            return False
+        if op == ">=" and not current >= target:
+            return False
+        if op == "<=" and not current <= target:
+            return False
+        if op == ">" and not current > target:
+            return False
+        if op == "<" and not current < target:
+            return False
+        if op == "^" and not (current >= target and current < _caret_upper(target)):
+            return False
+        if op == "~" and not (current >= target and current < _tilde_upper(target)):
+            return False
+    return True

solverpilot/history/__init__.py

@@ -0,0 +1,22 @@
+"""Optional local history storage for reproducible optimization research.
+
+Nothing is persisted unless a caller explicitly constructs :class:`HistoryStore`
+and records data. The schema intentionally excludes raw problem arrays and raw
+solution vectors.
+"""
+
+from .errors import HistoryDataError, HistorySchemaError, HistoryStoreError
+from .model import ProblemHistoryRecord, SolveHistoryRecord
+from .sqlite import HISTORY_SCHEMA_LABEL, HISTORY_SCHEMA_NAME, HISTORY_SCHEMA_VERSION, HistoryStore
+
+__all__ = [
+    "HISTORY_SCHEMA_LABEL",
+    "HISTORY_SCHEMA_NAME",
+    "HISTORY_SCHEMA_VERSION",
+    "HistoryDataError",
+    "HistorySchemaError",
+    "HistoryStoreError",
+    "HistoryStore",
+    "ProblemHistoryRecord",
+    "SolveHistoryRecord",
+]

solverpilot/history/errors.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from solverpilot.exceptions import SolverPilotError
+
+
+class HistoryStoreError(SolverPilotError):
+    """Base error for SolverPilot's optional local history store."""
+
+
+class HistorySchemaError(HistoryStoreError):
+    """Raised when a database schema is unsupported or inconsistent."""
+
+
+class HistoryDataError(HistoryStoreError):
+    """Raised when a record violates the history-store contract."""

solverpilot/history/model.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Mapping
+
+from solverpilot.io.hashing import deep_freeze_json, deep_thaw_json
+
+from .errors import HistoryDataError
+
+
+def _text(value: str, field_name: str) -> str:
+    if not isinstance(value, str) or not value.strip():
+        raise HistoryDataError(f"{field_name} must be a non-empty string")
+    return value.strip()
+
+
+def _sha(value: str, field_name: str) -> str:
+    text = _text(value, field_name).lower()
+    if len(text) != 64 or any(ch not in "0123456789abcdef" for ch in text):
+        raise HistoryDataError(f"{field_name} must be a SHA-256 digest")
+    return text
+
+
+def _json_object(value: Mapping[str, Any], field_name: str) -> Mapping[str, Any]:
+    if not isinstance(value, Mapping):
+        raise HistoryDataError(f"{field_name} must be a mapping")
+    try:
+        frozen = deep_freeze_json(value)
+    except Exception as exc:  # normalize lower-layer configuration errors
+        raise HistoryDataError(f"{field_name} must contain finite JSON-safe values") from exc
+    if not isinstance(frozen, Mapping):
+        raise HistoryDataError(f"{field_name} must form a JSON object")
+    return frozen
+
+
+@dataclass(frozen=True, slots=True)
+class ProblemHistoryRecord:
+    problem_data_hash: str
+    problem_structural_hash: str
+    problem_class: str
+    n_variables: int
+    n_constraints: int
+    source_provenance: Mapping[str, Any] = field(default_factory=dict)
+    metadata: Mapping[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "problem_data_hash", _sha(self.problem_data_hash, "problem_data_hash"))
+        object.__setattr__(self, "problem_structural_hash", _sha(self.problem_structural_hash, "problem_structural_hash"))
+        object.__setattr__(self, "problem_class", _text(self.problem_class, "problem_class"))
+        for name in ("n_variables", "n_constraints"):
+            value = getattr(self, name)
+            if type(value) is not int or value < 0:
+                raise HistoryDataError(f"{name} must be a non-negative integer")
+        object.__setattr__(self, "source_provenance", _json_object(self.source_provenance, "source_provenance"))
+        object.__setattr__(self, "metadata", _json_object(self.metadata, "metadata"))
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "problem_data_hash": self.problem_data_hash,
+            "problem_structural_hash": self.problem_structural_hash,
+            "problem_class": self.problem_class,
+            "n_variables": self.n_variables,
+            "n_constraints": self.n_constraints,
+            "source_provenance": deep_thaw_json(self.source_provenance),
+            "metadata": deep_thaw_json(self.metadata),
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class SolveHistoryRecord:
+    run_id: str
+    problem_data_hash: str
+    problem_structural_hash: str
+    problem_class: str
+    backend: str | None
+    backend_version: str | None
+    public_status: str
+    backend_status: str
+    objective: float | None
+    validation_valid: bool | None
+    independently_verified_optimal: bool
+    total_s: float | None
+    environment_id: str | None = None
+    trace_created_at_utc: str | None = None
+    metadata: Mapping[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        import math
+
+        object.__setattr__(self, "run_id", _text(self.run_id, "run_id"))
+        object.__setattr__(self, "problem_data_hash", _sha(self.problem_data_hash, "problem_data_hash"))
+        object.__setattr__(self, "problem_structural_hash", _sha(self.problem_structural_hash, "problem_structural_hash"))
+        object.__setattr__(self, "problem_class", _text(self.problem_class, "problem_class"))
+        object.__setattr__(self, "public_status", _text(self.public_status, "public_status"))
+        object.__setattr__(self, "backend_status", _text(self.backend_status, "backend_status"))
+        for name in ("backend", "backend_version", "environment_id", "trace_created_at_utc"):
+            value = getattr(self, name)
+            if value is not None:
+                object.__setattr__(self, name, _text(value, name))
+        if self.objective is not None and (type(self.objective) not in (int, float) or not math.isfinite(float(self.objective))):
+            raise HistoryDataError("objective must be finite when provided")
+        if self.total_s is not None and (type(self.total_s) not in (int, float) or not math.isfinite(float(self.total_s)) or float(self.total_s) < 0):
+            raise HistoryDataError("total_s must be finite and non-negative when provided")
+        if self.validation_valid is not None and type(self.validation_valid) is not bool:
+            raise HistoryDataError("validation_valid must be boolean or None")
+        if type(self.independently_verified_optimal) is not bool:
+            raise HistoryDataError("independently_verified_optimal must be boolean")
+        object.__setattr__(self, "objective", None if self.objective is None else float(self.objective))
+        object.__setattr__(self, "total_s", None if self.total_s is None else float(self.total_s))
+        object.__setattr__(self, "metadata", _json_object(self.metadata, "metadata"))
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "run_id": self.run_id,
+            "problem_data_hash": self.problem_data_hash,
+            "problem_structural_hash": self.problem_structural_hash,
+            "problem_class": self.problem_class,
+            "backend": self.backend,
+            "backend_version": self.backend_version,
+            "public_status": self.public_status,
+            "backend_status": self.backend_status,
+            "objective": self.objective,
+            "validation_valid": self.validation_valid,
+            "independently_verified_optimal": self.independently_verified_optimal,
+            "total_s": self.total_s,
+            "environment_id": self.environment_id,
+            "trace_created_at_utc": self.trace_created_at_utc,
+            "metadata": deep_thaw_json(self.metadata),
+        }