Validate → materialize → import → bind → meld

Prerequisites: an eligible agent room, configuration, and lifetimes. The complete application lesson starts with source strings and ends with working Python objects: a tokenizer, counter, reporter, and a population of independent workers.

Each verb answers a different question

Step	Result to inspect
`validate_codegen`	`accepted`, the selected frame, and any validation issues
`execute_codegen`	The execution payload, including `result` and error information
`materialize_codegen`	`materialized` and the named module's publication result
Import	The generated module's real classes
Bind and meld	Objects managed through the normal registration and lifetime rules

Validation checks the room's policy before execution; it does not prove arbitrary Python safe. Malformed requests and policy refusals have different result/error contracts. Inspect the returned payload before treating a call as completed work.

The complete application

Run Expert 36. It validates and materializes the generated modules, imports and binds the classes, then computes a word-frequency report. The assertions check that record occurs four times, that each object has the expected state, that unique reuses the tokenizer, and that five many workers have independent totals [1, 2, 3, 4, 5].

The core function below uses the source strings defined earlier in the saved file. Open the complete linked lesson to copy or download that setup.

Executing and keeping are separate

Materialization gives code a module address. A subsequent bind records its version and custody. The iteration lesson compares room memory with research history: running code does not itself declare a new research version. Subscribe to the room's memory system before operations when you want to observe those command records.

The workflow in code

These are the core steps from the saved example. Use its complete linked script for all class definitions and setup.

def main() -> None:
    crystallizer = md.Crystallizer()
    crystallizer.activate(
        md.CrystallizerConfigurationBuilder().with_defaults().activate(),
    )

    spellbook_configuration = (
        md.SpellbookConfiguration(FRAME).with_defaults().finalize()
    )
    book = md.Spellbook(aetheric_frame=FRAME,
                        configuration=spellbook_configuration)
    book.configure_aether_frame(
        system_state="dynamic",
        disposal=None,
        disposal_method_names=None,
        rift_enabled=True,
        ai_native=True,
    )
    conduit = book.conjure(name="build-root")

    nexus = md.Nexus()
    system_configuration = nexus.create_configuration()
    system_configuration.with_rift_creation_enabled(True)
    system_configuration.with_allowed_target_frame_names([FRAME])
    nexus.activate(system_configuration)
    rift_configuration = nexus.create_rift_configuration()
    rift_configuration.with_space_type("codegen")
    rift = nexus.create_rift(configuration=rift_configuration,
                             rift_name="builder")
    rift.mark_active()
    rift.create_frame_link(FRAME)
    commands = rift.space.command_system

    print("the process is up and NONE of the three classes exist yet")
    print()

    # WRITE THEM. Validate, materialize, import, bind - per piece.
    classes = {}
    for module_name, source, class_name in PARTS:
        verdict = commands.validate_codegen(source, frame_name=FRAME)
        assert verdict["accepted"] is True, verdict
        kept = commands.materialize_codegen(
            source, module_name=module_name, frame_name=FRAME,
        )
        assert kept["materialized"] is True, kept
        module = importlib.import_module(module_name)
        classes[class_name] = getattr(module, class_name)
        book.bind(spell=classes[class_name], existence="unique",
                  permissions="create", binding_name=class_name.lower())
        print("wrote %-9s -> module %-16s -> bound as '%s'"
              % (class_name, module_name, class_name.lower()))

    # MELD THEM. Now they are objects.
    tokenizer = conduit.meld(spell=classes["Tokenizer"],
                             binding_name="tokenizer")
    counter = conduit.meld(spell=classes["Counter"], binding_name="counter")
    reporter = conduit.meld(spell=classes["Reporter"],
                            binding_name="reporter")
    print()
    print("melded three OBJECTS:", type(tokenizer).__name__,
          type(counter).__name__, type(reporter).__name__)

    # RUN THE THING. This is real work done by code that did not exist
    # when this script started.
    words = tokenizer.run(TEXT)
    counts = counter.run(words)
    line = reporter.run(counts)
    print()
    print("input :", TEXT[:58], "...")
    print("output:", line)
    assert "record" in line, line
    assert counts["record"] == 4, counts
    print()
    print("that answer was computed by three classes an agent wrote as")
    print("strings, in this process, a few milliseconds ago")

    # THEY HAVE STATE, like any object.
    assert tokenizer.calls == 1
    assert counter.total == len(words)
    assert reporter.rendered == 1
    print()
    print("and they are ORDINARY objects: tokenizer.calls =",
          tokenizer.calls, "| counter.total =", counter.total)
    print("  no tongs required. Generated-ness stopped mattering the")
    print("  moment they landed")

    # UNIQUE MEANS THE SAME OBJECT BACK.
    again = conduit.meld(spell=classes["Tokenizer"],
                         binding_name="tokenizer")
    assert again is tokenizer, "existence='unique' returns the same object"
    print()
    print("melding 'tokenizer' again -> the SAME object:",
          again is tokenizer)

    # MANY MEANS A NEW ONE EVERY TIME - a population from one generated
    # class. This is its own class rather than a second binding of
    # Counter: two independent binds of one class would put two visible
    # spells under the same name, which the validator refuses (expert 30).
    commands.validate_codegen(WORKER, frame_name=FRAME)
    kept = commands.materialize_codegen(
        WORKER, module_name="build_worker", frame_name=FRAME,
    )
    assert kept["materialized"] is True, kept
    worker_class = importlib.import_module("build_worker").Worker
    book.bind(spell=worker_class, existence="many", permissions="create",
              binding_name="worker")

    workers = [conduit.meld(spell=worker_class, binding_name="worker")
               for _ in range(5)]
    assert len({id(worker) for worker in workers}) == 5, (
        "existence='many' must build a NEW instance per meld"
    )
    for index, worker in enumerate(workers):
        worker.run(["job"] * (index + 1))
    totals = [worker.total for worker in workers]
    assert totals == [1, 2, 3, 4, 5], totals
    print()
    print("a fourth generated class, bound existence='many':")
    print("  5 melds ->", len({id(w) for w in workers}), "distinct objects")
    print("  independent state:", totals)
    print("  one class an agent wrote, a population you control")

    print()
    print("string -> module -> spell -> object -> answer")
    print("and the module has no file, so its SOURCE IS THE RECORD -")
    print("which is why this world can be rebuilt, not just re-run")

Runnable examples

An agent builds a working system — Expert 36
The codegen room agents writing code — Expert 07
The codegen loop end to end — Expert 12
Codegen create modify iterate — Expert 26
What a synthetic module actually is — Expert 33
Deep overrides paths through a graph — Expert 10

All expert examples · Level contents · Full contents

Canonical page source