LUNA reproducibility results handbook

import luna_repro as repro
repro.connect("YOUR-PROJECT-UUID", label="My Colab")

import getpass
import luna_repro as repro
repro.configure(project="YOUR-PROJECT-UUID",
                endpoint="https://lunalab-ai.com",
                token=getpass.getpass("LUNA connection key: "))

%pip install --disable-pip-version-check --no-deps "https://github.com/lunalab-ai/luna-repro-sdk/releases/download/v0.3.0/luna_repro-0.3.0-py3-none-any.whl#sha256=4fc3b6a0ff1d78dbb2ace0ea08dcedc3794e14f3930d0c60f29c42fbb04e2489"

import luna_repro
print(luna_repro.__version__)

python -m pip install --disable-pip-version-check --no-deps "https://github.com/lunalab-ai/luna-repro-sdk/releases/download/v0.3.0/luna_repro-0.3.0-py3-none-any.whl#sha256=4fc3b6a0ff1d78dbb2ace0ea08dcedc3794e14f3930d0c60f29c42fbb04e2489"

python -c "import luna_repro; print(luna_repro.__version__)"

py -m venv .venv
.\.venv\Scripts\Activate.ps1

python3 -m venv .venv
source .venv/bin/activate

python ./examples/walkthrough.py

$env:LUNA_REPRO_ENDPOINT = "https://lunalab-ai.com"
python ./examples/walkthrough.py --project "YOUR-PROJECT-UUID" --publish

export LUNA_REPRO_ENDPOINT="https://lunalab-ai.com"
python ./examples/walkthrough.py --project "YOUR-PROJECT-UUID" --publish

python -m pip install --force-reinstall --disable-pip-version-check --no-deps "https://github.com/lunalab-ai/luna-repro-sdk/releases/download/v0.3.0/luna_repro-0.3.0-py3-none-any.whl#sha256=4fc3b6a0ff1d78dbb2ace0ea08dcedc3794e14f3930d0c60f29c42fbb04e2489"

from pathlib import Path
import math
import luna_repro as repro

project_id = "12345678-1234-5678-1234-567812345678"  # Offline practice only
reference = [0.0, 1.0, 2.0, 3.0, 4.0, 5.0]
prediction = [value + 0.5 for value in reference]
errors = [actual - expected for actual, expected in zip(prediction, reference)]
metrics = {
    "MAE": sum(abs(error) for error in errors) / len(errors),
    "RMSE": math.sqrt(sum(error ** 2 for error in errors) / len(errors)),
    "samples": len(reference),
}
rows = [[i, target, actual] for i, (target, actual)
        in enumerate(zip(reference, prediction))]

page = repro.page(
    project_id,
    "My first synthetic result",
    description="Practice result registration using six synthetic values.",
    metadata={"tags": ["synthetic", "practice"]},
    evidence={"origin": "synthetic", "execution_status": "completed",
              "evaluation_status": "completed"},
)
page.section("conditions", "Conditions").text("Added 0.5 to each reference value.")
page.section("quality", "Quantitative results").metrics(metrics).table(
    ["index", "reference", "prediction"], rows
)
output = Path(".luna-repro") / ("practice-" + page.page_id + ".json")
page.save(output)
print(metrics)  # MAE=0.5, RMSE=0.5, samples=6
print("Saved locally:", output)

if page.project_id == "12345678-1234-5678-1234-567812345678":
    raise ValueError('Rebuild the Page using your real project UUID first.')
repro.connect(page.project_id, endpoint="https://lunalab-ai.com")
receipt = repro.publish(page)
if receipt["status"] == "published":
    print("Published:", receipt["url"], "revision:", receipt["revision"])
else:
    print("Pending:", receipt["code"], receipt["message"])
    print("Preserved:", receipt.get("outbox_path"))

import luna_repro as repro
selection = repro.select()

receipt = repro.publish(metrics, comparison_df, figure, title="My experiment results")
print(receipt["status"], receipt.get("url"))

page = repro.page(project_id, "My experiment results")
page.section("quality", "Evaluation").metrics(metrics)
page.section("comparison", "Method comparison").table(comparison_df)
page.section("render", "Visual result").figure(figure, "Selected result figure")
receipt = repro.publish(page)  # Uses the current connect/configure connection

import luna_repro as repro

project_id = "12345678-1234-5678-1234-567812345678"  # Replace before publication
page = repro.page(project_id, "Staged synthetic experiment", evidence={
    "origin": "synthetic", "execution_status": "unknown",
    "evaluation_status": "not_run",
})
page.section("setup", "Setup").text("Reference [1, 2, 3], prediction [1.2, 1.8, 3.1]")
page.save(".luna-repro/incremental-example-partial.json")

reference = [1.0, 2.0, 3.0]
prediction = [1.2, 1.8, 3.1]
mae = sum(abs(a - b) for a, b in zip(reference, prediction)) / len(reference)
page.section("quality", "Evaluation").metrics({"MAE": mae})
page.evidence.update(execution_status="completed", evaluation_status="completed")
page.save(".luna-repro/incremental-example-complete.json")

import uuid
# saved_page_id is the page_id from an earlier successful receipt.
next_run = repro.page(project_id, "Follow-up execution", page_id=saved_page_id,
                     run_id=str(uuid.uuid4()))
next_run.section("notes", "Scope of this run").text("Results selected for this execution.")

page.section("notes", "Explanation", description="Conditions readers need first").text(
    "Used six inputs.\nThese values are synthetic."
)

page.section("quality", "Quantitative evaluation").metrics({
    "MAE (mm)": 0.25,
    "samples": 24,
    "inference_seconds": 1.8,
})

page.section("table", "Per-case results").table(
    ["case", "score", "passed", "comment"],
    [["A", 0.25, True, "checked"], ["B", None, False, "not evaluated"]],
)

import pandas as pd  # Needed only in research environments using pandas
selected = df[["case", "score"]].copy()
selected = selected.astype(object).where(pd.notna(selected), None)
page.section("comparison", "Comparison table").table(selected)
# Use selected.reset_index() if the index itself is meaningful.

from pathlib import Path
image_path = Path("selected_render.png")  # An existing, explicitly selected image
page.section("render", "Front render").image(image_path, "Reconstruction viewed from the front")

# image_bytes contains PNG or JPEG bytes produced by your code.
page.section("preview", "Preview").image(image_bytes, "Selected result", name="preview.png")

import matplotlib.pyplot as plt  # Needed only when using matplotlib
fig, ax = plt.subplots()
ax.plot([0, 1, 2], [0.5, 1.5, 2.5], marker="o")
ax.set(xlabel="sample", ylabel="value", title="Synthetic values")
page.section("plot", "Synthetic chart").figure(fig, "Three synthetic values")
plt.close(fig)

import subprocess

commit = subprocess.check_output(
    ["git", "rev-parse", "HEAD"], text=True
).strip()
repository_url = "https://github.com/ORG/REPO"  # Replace with the real repository
source = {
    "repository_url": repository_url,
    "commit": commit,
    "file": "src/inference.py",  # Actual repository-relative computation path
    "line_start": 40,
    "line_end": 63,
    "url": repository_url + "/blob/" + commit + "/src/inference.py#L40-L63",
}
page.section("quality", "Evaluation", source=source)

notebook_url = "https://colab.research.google.com/drive/NOTEBOOK-ID"
page.section("render", "Reconstruction", source={
    "file": "experiment.ipynb",
    "cell_id": "REAL-CELL-ID",
    "url": notebook_url + "#scrollTo=REAL-CELL-ID",
    "execution_url": notebook_url,
})

First verify this result's pinned version and code provenance.
Identify evaluated inputs, units, omitted conditions and failure records.
Separate conclusions supported by these numbers from unsupported claims.
Inspect the actual accessible code, then propose the next experiment and changes.
Do not start training, GPU execution or external publication yet.

import luna_repro as repro
outcomes = repro.sync(".luna-repro/outbox")
for receipt in outcomes:
    print(receipt["status"], receipt.get("url") or receipt["code"])

python -m luna_repro sync --outbox .luna-repro/outbox
python -m luna_repro publish selected-result.json

from pasa_adapter import build_page

RUN_DIR = "/content/my-existing-pasa-run"  # Replace with the actual output directory
project_id = "12345678-1234-5678-1234-567812345678"  # Replace with the real project UUID
page = build_page(RUN_DIR, project=project_id)
page.save(".luna-repro/pasa-selected-result.json")
# Run explicitly after reviewing the connection, project and selected content:
# receipt = page.publish()
# print(receipt["status"], receipt.get("url") or receipt["message"])

repro.page(project, title, *, description="", endpoint=None, token=None,
           page_id=None, run_id=None, metadata=None, evidence=None,
           source=None, outbox=None)

bundle = repro.load_bundle("selected-result.json")
# Returns a dict; it does not reconstruct a Page object.
receipt = repro.publish_bundle(bundle, timeout=30)
outcomes = repro.sync(".luna-repro/outbox", timeout=30)

from pathlib import Path
import luna_repro as repro


def calculate():
    reference = [0.0, 1.0, 2.0]
    prediction = [value + 0.5 for value in reference]
    return sum(abs(a - b) for a, b in zip(prediction, reference)) / len(reference)


selected = repro.source.function(
    calculate, root=Path(__file__).resolve().parent, snapshot=True,
)
page = repro.page(
    "12345678-1234-5678-1234-567812345678", "Source selection practice",
    evidence={"origin": "synthetic", "execution_status": "completed",
              "evaluation_status": "completed"},
)
page.section("metric", "Computed MAE", source=selected).metrics({"MAE": calculate()})
saved = page.save(Path(".luna-repro") / (page.page_id + ".json"))
print("Saved locally:", saved)
print("Source:", selected["file"], selected["line_start"], selected["line_end"])
print("Selected code SHA256:", selected["snapshot_sha256"])

from pathlib import Path
import luna_repro as repro

notebook_path = Path("saved_notebook.ipynb")
selected = repro.source.notebook(
    notebook_path, "ACTUAL-COLAB-CELL-ID",
    root=notebook_path.resolve().parent,
    provider="colab",
    notebook_url="https://colab.research.google.com/drive/ACTUAL-NOTEBOOK-ID",
    snapshot=True,
    role="reference",
)

Background and research question   ← narrative cell
Experiment A render                ← result cell at a fixed version
Data and evaluation methods        ← narrative cell
Experiment B metrics               ← result from another page
Comparison, limitations, next test  ← narrative cell

from pathlib import Path
import luna_repro as repro

repro.configure(project="12345678-1234-5678-1234-567812345678")
metrics = {"MAE": 0.5, "samples": 3}
comparison = [[0, 0.0, 0.5], [1, 1.0, 1.5], [2, 2.0, 2.5]]
selection = repro.select(
    namespace={"metrics": metrics, "comparison": comparison},
    title="Local selection practice", show=False,
)
print(selection.summary())  # Candidate names/types/reasons, not complete source values
selection.choose("metrics", "comparison")
selection.option("comparison", columns=["index", "reference", "prediction"])
selection.edit(description="Three synthetic values, not actual research performance.",
               order=["comparison", "metrics"])
folder = Path(".luna-repro") / "selection-practice"
selection.preview(folder / "preview.html")
selection.save(folder / "selected.json")
print("Local preview:", folder / "preview.html")

selection = repro.select(namespace={"results": results_df}, show=False)
selection.choose("results")
selection.option("results", rows=50, columns=["method", "score"], index=False)
selection.preview(".luna-repro/results-preview.html")

import matplotlib.pyplot as plt
with repro.capture(max_figures=4) as captured:
    plt.plot([0, 1, 2], [0, 1, 4])
    plt.show()
    plt.close()
captured_selection = captured.select(show=False)
captured_selection.preview(".luna-repro/captured-preview.html")