Datasets:
File size: 4,742 Bytes
e1ced61 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 | """Emit ``compiled_program`` records for the C2 dual-compile (``docs/02`` §7).
Each model produces one ``compiled_program`` row conforming to
``schemas/compiled_program.schema.json``. The record is content-addressed:
``compile_id`` is the SHA-256 of the canonical-JSON of the record's identity
fields (role + pinned model + base id + question/choices hashes + request +
response), so the same ``(model, request, response)`` always reproduces the same
``compile_id`` and a different response always changes it.
A compiled program carries the full envelope (``dsl`` / ``program`` /
``referent_selector`` / ``required_referent_cardinality`` /
``referenced_node_ids`` / ``canonical_program_sha256``). A non-compiled outcome
(``invalid_response`` for a parse failure, ``unsupported`` for a model-declined
compile) carries a ``reason_code`` and no program — never a fabricated program.
"""
from __future__ import annotations
from functools import lru_cache
from typing import Any, Literal
from ..dsl.ast import CompileStatus
from ..hashing import canonical_json_hash
from ..paths import repo_root
from ..schema_io import is_valid, load_schema
from .parse import ParsedProgram
CompilerRole = Literal["program_proposer", "independent_program_verifier"]
ParseStatus = Literal["valid_first_response", "valid_after_one_repair", "invalid"]
@lru_cache(maxsize=1)
def _schema() -> dict[str, Any]:
return load_schema(repo_root() / "schemas" / "compiled_program.schema.json")
def build_compiled_program(
*,
base_id: str,
question_sha256: str,
choices_sha256: str,
compiler_role: CompilerRole,
model_repo_id: str,
model_revision: str,
request_sha256: str,
response_sha256: str,
parse_status: ParseStatus,
parsed: ParsedProgram | None = None,
compile_status: CompileStatus | None = None,
reason_code: str | None = None,
) -> dict[str, Any]:
"""Assemble a schema-valid ``compiled_program`` record.
``parsed.ok`` ⇒ ``compile_status="compiled"`` with the full envelope; else
``compile_status`` defaults to ``"invalid_response"`` (or the caller-supplied
``"unsupported"``) with a required ``reason_code``. The returned dict is
validated against the schema; a non-conforming record raises (never silently
emitted).
"""
record: dict[str, Any] = {
"schema_version": 1,
"base_id": base_id,
"compiler_role": compiler_role,
"model": {"repo_id": model_repo_id, "revision": model_revision},
"question_sha256": question_sha256,
"choices_sha256": choices_sha256,
"request_sha256": request_sha256,
"response_sha256": response_sha256,
"parse_status": parse_status,
}
if parsed is not None and parsed.ok and parsed.program is not None:
prog = parsed.program
record["compile_status"] = "compiled"
record["dsl"] = prog.dsl
record["program"] = prog.program.to_ast_node_dict()
record["referent_selector"] = (
prog.referent_selector.to_ast_node_dict() if prog.referent_selector else None
)
record["required_referent_cardinality"] = prog.required_referent_cardinality
record["referenced_node_ids"] = list(prog.referenced_node_ids)
record["canonical_program_sha256"] = parsed.canonical_program_sha256
else:
record["compile_status"] = compile_status or "invalid_response"
record["reason_code"] = reason_code or _default_reason(parse_status, parsed)
record["compile_id"] = _compile_id(record)
_validate(record)
return record
def _default_reason(parse_status: ParseStatus, parsed: ParsedProgram | None) -> str:
if parsed is not None and not parsed.ok and parsed.errors:
return "parse_failed: " + "; ".join(parsed.errors[:3])
if parse_status == "invalid":
return "invalid_response"
return "unsupported"
def _compile_id(record: dict[str, Any]) -> str:
"""Content-addressed id over the stable identity fields (not compile_status)."""
identity = {
"compiler_role": record["compiler_role"],
"model": record["model"],
"base_id": record["base_id"],
"question_sha256": record["question_sha256"],
"choices_sha256": record["choices_sha256"],
"request_sha256": record["request_sha256"],
"response_sha256": record["response_sha256"],
}
return canonical_json_hash(identity)
def _validate(record: dict[str, Any]) -> None:
schema = _schema()
if not is_valid(record, schema):
from ..schema_io import validate
errors = validate(record, schema)
raise ValueError("compiled_program record failed schema: " + "; ".join(errors))
__all__ = ["build_compiled_program"]
|