data-morph-gemma 0.1.0__py3-none-any.whl

datamorph/data/collect.py

@@ -0,0 +1,221 @@
+"""Stage 3+4+5 orchestrator: envelope -> teacher script -> sandbox -> verify.
+
+The teacher is injected as `teacher_fn` so the loop is fully testable without
+any API calls. `collect_corpus` is the batch driver used by the CLI.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Callable
+
+from datamorph.data.envelope import extract_envelope
+from datamorph.data.generators.base import EXT_BY_FORMAT
+from datamorph.data.sandbox import run_script
+from datamorph.data.teacher_script import ScriptResult, call_script_teacher
+from datamorph.evaluation.metrics import score_all
+from datamorph.evaluation.runner import CaseSpec, discover_cases
+
+CA_MIN = 0.95
+TeacherFn = Callable[..., ScriptResult]
+
+
+@dataclass
+class PairResult:
+    case_id: str
+    use_case: str
+    complexity: str
+    input_format: str
+    output_format: str
+    accepted: bool = False
+    scores: dict[str, float] = field(default_factory=dict)
+    retries: int = 0
+    error_kind: str = ""
+    reason: str = ""
+    envelope: dict[str, Any] = field(default_factory=dict)
+    instruction: str = ""
+    analysis: str = ""
+    script: str = ""
+    teacher_usage: dict[str, Any] | None = None  # Opus token usage (cost + W6 analysis)
+
+
+def _passes(scores: dict[str, float]) -> bool:
+    return (
+        scores.get("format_validity", 0.0) == 1.0
+        and scores.get("loadability", 0.0) == 1.0
+        and scores.get("schema_compliance", 0.0) == 1.0
+        and scores.get("content_accuracy", 0.0) >= CA_MIN
+    )
+
+
+def _failing_metrics(scores: dict[str, float]) -> list[str]:
+    failing = []
+    for k in ("format_validity", "loadability", "schema_compliance"):
+        if scores.get(k, 0.0) < 1.0:
+            failing.append(k)
+    if scores.get("content_accuracy", 0.0) < CA_MIN:
+        failing.append("content_accuracy")
+    return failing
+
+
+def collect_case(
+    case: CaseSpec,
+    *,
+    teacher_fn: TeacherFn = call_script_teacher,
+    max_retries: int = 3,
+) -> PairResult:
+    """Run the full teach->run->verify loop for one case, retrying with feedback."""
+    meta = case.meta
+    in_ext = EXT_BY_FORMAT[meta["input_format"]]
+    out_ext = EXT_BY_FORMAT[meta["output_format"]]
+    input_path = case.case_dir / f"input{in_ext}"
+
+    envelope = extract_envelope(input_path, meta["input_format"])
+    envelope.pop("file_path", None)  # don't leak local paths into training data
+    instruction = meta.get("prompt_hint") or (
+        f"Convert this {meta['input_format'].upper()} to {meta['output_format'].upper()}."
+    )
+
+    result = PairResult(
+        case_id=case.case_id,
+        use_case=meta["use_case"],
+        complexity=meta["complexity"],
+        input_format=meta["input_format"],
+        output_format=meta["output_format"],
+        envelope=envelope,
+        instruction=instruction,
+    )
+
+    feedback: str | None = None
+    for attempt in range(max_retries + 1):
+        result.retries = attempt
+        tr = teacher_fn(envelope, instruction, meta["output_format"], feedback=feedback)
+        # Capture token usage from the latest teacher response (claude -p JSON
+        # payload carries it). One-shot data — not recoverable after the run.
+        usage = tr.raw_payload.get("usage") if tr.raw_payload else None
+        if usage:
+            result.teacher_usage = usage
+        if not tr.ok:
+            result.error_kind = "no_script"
+            result.reason = f"teacher produced no <script> (stderr: {tr.stderr[:200]})"
+            feedback = result.reason
+            continue
+
+        sr = run_script(tr.script, input_path, output_suffix=out_ext)
+        if not sr.ok:
+            result.error_kind = sr.error_kind
+            result.reason = f"script {sr.error_kind}: {sr.stderr[:300]}"
+            result.analysis, result.script = tr.analysis, tr.script
+            feedback = result.reason
+            continue
+
+        scores = score_all(
+            actual=sr.output_text,
+            expected=case.expected_text,
+            output_format=meta["output_format"],
+            required_substrings=meta.get("required_substrings"),
+        )
+        result.scores = scores
+        result.analysis, result.script = tr.analysis, tr.script
+        if _passes(scores):
+            result.accepted = True
+            result.error_kind = "ok"
+            result.reason = ""
+            return result
+        failing = _failing_metrics(scores)
+        result.error_kind = "low_score"
+        result.reason = f"output scored low on {failing}: {scores}"
+        feedback = result.reason
+
+    return result
+
+
+def collect_corpus(
+    raw_root: Path,
+    interim_root: Path,
+    *,
+    teacher_fn: TeacherFn = call_script_teacher,
+    max_retries: int = 3,
+    limit: int | None = None,
+    resume: bool = False,
+) -> dict[str, Any]:
+    """Run collect_case over every corpus case; write accepted records + a manifest.
+
+    When ``resume`` is True, any case that already has an accepted record file in
+    ``interim_root`` is skipped without calling the teacher, so an interrupted run
+    (e.g. one stopped by a teacher usage limit) can be continued without
+    re-spending Opus calls on pairs already collected.
+    """
+    cases = discover_cases(raw_root)
+    if limit is not None:
+        cases = cases[:limit]
+    interim_root.mkdir(parents=True, exist_ok=True)
+
+    manifest: list[dict[str, Any]] = []
+    n_accepted = 0
+    n_skipped = 0
+    for case in cases:
+        out_path = interim_root / f"{case.meta['use_case']}__{case.case_dir.name}.json"
+        if resume and out_path.exists():
+            n_skipped += 1
+            manifest.append(
+                {
+                    "case_id": case.case_id,
+                    "use_case": case.meta["use_case"],
+                    "accepted": True,
+                    "error_kind": "skipped_existing",
+                    "retries": 0,
+                    "scores": {},
+                    "reason": "",
+                }
+            )
+            continue
+        res = collect_case(case, teacher_fn=teacher_fn, max_retries=max_retries)
+        if res.accepted:
+            n_accepted += 1
+            record = {
+                "case_id": res.case_id,
+                "use_case": res.use_case,
+                "complexity": res.complexity,
+                "input_format": res.input_format,
+                "output_format": res.output_format,
+                "envelope": res.envelope,
+                "instruction": res.instruction,
+                "analysis": res.analysis,
+                "script": res.script,
+                "scores": res.scores,
+                "retries": res.retries,
+                "teacher_usage": res.teacher_usage,
+            }
+            out_path = interim_root / f"{res.use_case}__{case.case_dir.name}.json"
+            out_path.write_text(json.dumps(record, indent=2, default=str), encoding="utf-8")
+        manifest.append(
+            {
+                "case_id": res.case_id,
+                "use_case": res.use_case,
+                "accepted": res.accepted,
+                "error_kind": res.error_kind,
+                "retries": res.retries,
+                "scores": res.scores,
+                "reason": res.reason if not res.accepted else "",
+            }
+        )
+
+    n_attempted = len(cases) - n_skipped
+    summary = {
+        "n_cases": len(cases),
+        "n_skipped": n_skipped,
+        "n_attempted": n_attempted,
+        "n_accepted": n_accepted,
+        "n_records_total": n_accepted + n_skipped,
+        # accept_rate is over cases actually attempted this run (skipped ones
+        # were already accepted), so a resumed run's rate stays meaningful.
+        "accept_rate": round(n_accepted / n_attempted, 3) if n_attempted else 0.0,
+        "results": manifest,
+    }
+    (interim_root / "collect_manifest.json").write_text(
+        json.dumps(summary, indent=2, default=str), encoding="utf-8"
+    )
+    return summary

datamorph/data/envelope.py

@@ -0,0 +1,20 @@
+"""Dispatch a source file to the right Stage-1 extractor and return its envelope."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from datamorph.extractor import CSVExtractor, JSONExtractor, MetadataExtractor, TXTExtractor
+
+_EXTRACTORS: dict[str, type[MetadataExtractor]] = {
+    "csv": CSVExtractor,
+    "json": JSONExtractor,
+    "txt": TXTExtractor,
+}
+
+
+def extract_envelope(input_path: Path, input_format: str) -> dict[str, Any]:
+    """Return the metadata envelope for `input_path`, dispatching by `input_format`."""
+    extractor_cls = _EXTRACTORS[input_format]  # KeyError on unknown format is intentional
+    return extractor_cls().extract(input_path)

datamorph/data/generators/__init__.py

@@ -0,0 +1 @@
+"""Synthetic source-file generators — the ground-truth oracle."""

datamorph/data/generators/base.py

@@ -0,0 +1,48 @@
+"""Shared primitives for the synthetic source-file generators (the oracle)."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from faker import Faker
+
+EXT_BY_FORMAT = {"csv": ".csv", "json": ".json", "txt": ".txt"}
+
+
+@dataclass(frozen=True)
+class GeneratedCase:
+    """A single synthetic conversion case — both sides built from one seed."""
+
+    use_case: str
+    complexity: str
+    input_format: str
+    output_format: str
+    input_text: str
+    expected_text: str
+    meta: dict[str, Any]
+
+
+def make_faker(seed: int) -> Faker:
+    """Return a Faker whose output is deterministic for the given seed."""
+    fake = Faker()
+    fake.seed_instance(seed)
+    return fake
+
+
+def write_case(case: GeneratedCase, dest_root: Path, case_name: str) -> Path:
+    """Write input/expected/meta into dest_root/<use_case>/<case_name>/ (test_set layout)."""
+    case_dir = dest_root / case.use_case / case_name
+    case_dir.mkdir(parents=True, exist_ok=True)
+    (case_dir / f"input{EXT_BY_FORMAT[case.input_format]}").write_text(
+        case.input_text, encoding="utf-8"
+    )
+    (case_dir / f"expected{EXT_BY_FORMAT[case.output_format]}").write_text(
+        case.expected_text, encoding="utf-8"
+    )
+    (case_dir / "meta.json").write_text(
+        json.dumps(case.meta, indent=2) + "\n", encoding="utf-8"
+    )
+    return case_dir

datamorph/data/generators/uc1_csv_to_json.py

@@ -0,0 +1,64 @@
+"""Generator: flat CSV (user_*/order_*) -> nested JSON (user object + orders array)."""
+
+from __future__ import annotations
+
+import csv
+import io
+import json
+import random
+
+from .base import GeneratedCase, make_faker
+
+_N_USERS = {"simple": 3, "medium": 8, "complex": 20}
+_MAX_ORDERS = {"simple": 1, "medium": 3, "complex": 5}
+_ITEMS = ["Widget", "Gadget", "Thingamajig", "Doohickey", "Sprocket", "Cog"]
+
+
+def generate(seed: int, complexity: str) -> GeneratedCase:
+    rng = random.Random(seed)
+    fake = make_faker(seed)
+    n_users = _N_USERS[complexity]
+    max_orders = _MAX_ORDERS[complexity]
+
+    rows: list[tuple[str, str, int, str, float]] = []
+    records: list[dict] = []
+    oid = 1000
+    for i in range(n_users):
+        name = f"{fake.first_name()}{i}"  # index suffix guarantees uniqueness
+        email = f"{name.lower()}@example.com"
+        n_orders = 1 if complexity == "simple" else rng.randint(1, max_orders)
+        orders = []
+        for _ in range(n_orders):
+            oid += 1
+            item = rng.choice(_ITEMS)
+            price = round(rng.uniform(1, 100), 2)
+            rows.append((name, email, oid, item, price))
+            orders.append({"id": oid, "item": item, "price": price})
+        records.append({"user": {"name": name, "email": email}, "orders": orders})
+
+    buf = io.StringIO()
+    writer = csv.writer(buf, lineterminator="\n")
+    writer.writerow(["user_name", "user_email", "order_id", "order_item", "order_price"])
+    writer.writerows(rows)
+    input_text = buf.getvalue()
+    expected_text = json.dumps(records, indent=2) + "\n"
+
+    meta = {
+        "use_case": "uc1_csv_to_json_nested",
+        "complexity": complexity,
+        "input_format": "csv",
+        "output_format": "json",
+        "description": (
+            "Flat CSV with user_* and order_* columns -> nested JSON with user "
+            "object and orders array"
+        ),
+        "prompt_hint": (
+            "Group rows by user (user_name/user_email). user_* fields nest under "
+            "'user'; order_* fields become objects in an 'orders' array. Keep "
+            "order_id/order_price numeric (do not quote)."
+        ),
+        "seed": seed,
+    }
+    return GeneratedCase(
+        "uc1_csv_to_json_nested", complexity, "csv", "json", input_text, expected_text, meta
+    )

datamorph/data/generators/uc2_json_to_csv.py

@@ -0,0 +1,59 @@
+"""Generator: nested JSON (name + address object) -> flattened CSV (dot-notation columns)."""
+
+from __future__ import annotations
+
+import csv
+import io
+import json
+import random
+
+from .base import GeneratedCase, make_faker
+
+_N = {"simple": 3, "medium": 8, "complex": 20}
+
+
+def generate(seed: int, complexity: str) -> GeneratedCase:
+    rng = random.Random(seed)
+    fake = make_faker(seed)
+    include_age = complexity != "simple"
+
+    records: list[dict] = []
+    for i in range(_N[complexity]):
+        # Strip commas from city so the oracle CSV stays comma-clean.
+        city = fake.city().replace(",", "")
+        rec: dict = {
+            "name": f"{fake.first_name()}{i}",
+            "address": {"city": city, "zip": str(fake.postcode())},
+        }
+        if include_age:
+            rec["age"] = rng.randint(18, 80)
+        records.append(rec)
+
+    input_text = json.dumps(records, indent=2) + "\n"
+
+    cols = ["name", "address.city", "address.zip"] + (["age"] if include_age else [])
+    buf = io.StringIO()
+    writer = csv.writer(buf, lineterminator="\n")
+    writer.writerow(cols)
+    for r in records:
+        row = [r["name"], r["address"]["city"], r["address"]["zip"]]
+        if include_age:
+            row.append(r["age"])
+        writer.writerow(row)
+    expected_text = buf.getvalue()
+
+    meta = {
+        "use_case": "uc2_json_to_csv_flatten",
+        "complexity": complexity,
+        "input_format": "json",
+        "output_format": "csv",
+        "description": "Nested JSON records -> flattened CSV with dot-notation columns",
+        "prompt_hint": (
+            "Flatten nested keys with dot notation (address.city, address.zip). "
+            "One CSV row per record. Header order: " + ",".join(cols) + "."
+        ),
+        "seed": seed,
+    }
+    return GeneratedCase(
+        "uc2_json_to_csv_flatten", complexity, "json", "csv", input_text, expected_text, meta
+    )

datamorph/data/generators/uc3_txt_log_to_csv.py

@@ -0,0 +1,64 @@
+"""Generator: bracketed-timestamp logs (TXT) -> CSV (timestamp,level,source,message)."""
+
+from __future__ import annotations
+
+import csv
+import io
+import random
+from datetime import datetime, timedelta
+
+from .base import GeneratedCase
+
+_LEVELS = ["INFO", "WARN", "ERROR", "DEBUG"]
+_SOURCES = ["app", "db", "auth", "cache", "api"]
+# Comma-free messages keep the oracle CSV unquoted and exactly verifiable.
+_MESSAGES = [
+    "Server started",
+    "Connection lost",
+    "Slow query detected",
+    "Reconnecting",
+    "User login succeeded",
+    "Cache miss",
+    "Request handled",
+    "Disk space low",
+]
+_N_LINES = {"simple": 6, "medium": 30, "complex": 120}
+
+
+def generate(seed: int, complexity: str) -> GeneratedCase:
+    rng = random.Random(seed)
+    n = _N_LINES[complexity]
+    t = datetime(2026, 4, 15, 10, 0, 0)
+
+    in_lines: list[str] = []
+    rows: list[tuple[str, str, str, str]] = []
+    for _ in range(n):
+        t = t + timedelta(seconds=rng.randint(1, 90))
+        level = rng.choice(_LEVELS)
+        source = rng.choice(_SOURCES)
+        msg = rng.choice(_MESSAGES)
+        in_lines.append(f"[{t:%Y-%m-%d %H:%M:%S}] {level} {source}: {msg}")
+        rows.append((f"{t:%Y-%m-%dT%H:%M:%S}", level, source, msg))
+
+    input_text = "\n".join(in_lines) + "\n"
+    buf = io.StringIO()
+    writer = csv.writer(buf, lineterminator="\n")
+    writer.writerow(["timestamp", "level", "source", "message"])
+    writer.writerows(rows)
+    expected_text = buf.getvalue()
+
+    meta = {
+        "use_case": "uc3_txt_log_to_csv",
+        "complexity": complexity,
+        "input_format": "txt",
+        "output_format": "csv",
+        "description": "Bracketed-timestamp logs -> CSV timestamp,level,source,message",
+        "prompt_hint": (
+            "Each line: [YYYY-MM-DD HH:MM:SS] LEVEL source: message. Output CSV "
+            "columns timestamp (ISO-8601 YYYY-MM-DDTHH:MM:SS), level, source, message."
+        ),
+        "seed": seed,
+    }
+    return GeneratedCase(
+        "uc3_txt_log_to_csv", complexity, "txt", "csv", input_text, expected_text, meta
+    )

datamorph/data/generators/uc4_csv_to_txt_report.py

@@ -0,0 +1,62 @@
+"""Generator: regional sales CSV -> human-readable TXT report with totals."""
+
+from __future__ import annotations
+
+import csv
+import io
+import random
+
+from .base import GeneratedCase
+
+_POOL = [
+    "North", "South", "East", "West", "Central",
+    "Northeast", "Southwest", "Northwest", "Southeast",
+]
+_N = {"simple": 4, "medium": 6, "complex": 9}
+
+
+def generate(seed: int, complexity: str) -> GeneratedCase:
+    rng = random.Random(seed)
+    regions = _POOL[: _N[complexity]]
+    data: list[tuple[str, int, int]] = [
+        (reg, rng.randint(1000, 20000), rng.randint(5, 50)) for reg in regions
+    ]
+    total_sales = sum(s for _, s, _ in data)
+    total_units = sum(u for _, _, u in data)
+
+    buf = io.StringIO()
+    writer = csv.writer(buf, lineterminator="\n")
+    writer.writerow(["region", "sales", "units"])
+    for row in data:
+        writer.writerow(row)
+    input_text = buf.getvalue()
+
+    lines = ["Sales Report by Region", "======================", "Region    Sales    Units"]
+    for reg, s, u in data:
+        lines.append(f"{reg:<10}{s:<9}{u}")
+    lines += ["", f"Total Sales: {total_sales}", f"Total Units: {total_units}"]
+    expected_text = "\n".join(lines) + "\n"
+
+    required = ["Sales Report"]
+    for reg, s, _ in data:
+        required.extend([reg, str(s)])
+    required += [f"Total Sales: {total_sales}", f"Total Units: {total_units}"]
+
+    meta = {
+        "use_case": "uc4_csv_to_txt_report",
+        "complexity": complexity,
+        "input_format": "csv",
+        "output_format": "txt",
+        "description": "Regional sales CSV -> human-readable TXT report with totals",
+        "prompt_hint": (
+            "Produce a plain-text report titled 'Sales Report by Region', an "
+            "aligned table of the regions, then two summary lines "
+            "'Total Sales: <sum>' and 'Total Units: <sum>'."
+        ),
+        "content_accuracy_mode": "txt_substring",
+        "required_substrings": required,
+        "seed": seed,
+    }
+    return GeneratedCase(
+        "uc4_csv_to_txt_report", complexity, "csv", "txt", input_text, expected_text, meta
+    )

datamorph/data/generators/uc5_schema_migration.py

@@ -0,0 +1,49 @@
+"""Generator: JSON schema migration — rename user_* keys to bare names."""
+
+from __future__ import annotations
+
+import json
+import random
+
+from .base import GeneratedCase, make_faker
+
+_N = {"simple": 3, "medium": 8, "complex": 20}
+
+
+def generate(seed: int, complexity: str) -> GeneratedCase:
+    rng = random.Random(seed)
+    fake = make_faker(seed)
+    include_age = complexity != "simple"
+
+    src: list[dict] = []
+    dst: list[dict] = []
+    for i in range(_N[complexity]):
+        name = f"{fake.first_name()}{i}"
+        email = f"{name.lower()}@example.com"
+        s: dict = {"user_name": name, "user_email": email}
+        d: dict = {"name": name, "email": email}
+        if include_age:
+            age = rng.randint(18, 80)
+            s["user_age"] = age
+            d["age"] = age
+        src.append(s)
+        dst.append(d)
+
+    input_text = json.dumps(src, indent=2) + "\n"
+    expected_text = json.dumps(dst, indent=2) + "\n"
+
+    meta = {
+        "use_case": "uc5_schema_migration",
+        "complexity": complexity,
+        "input_format": "json",
+        "output_format": "json",
+        "description": "JSON schema migration — rename user_* keys to bare names",
+        "prompt_hint": (
+            "Rename keys on every record: user_name->name, user_email->email, "
+            "user_age->age. Preserve values and record order."
+        ),
+        "seed": seed,
+    }
+    return GeneratedCase(
+        "uc5_schema_migration", complexity, "json", "json", input_text, expected_text, meta
+    )

datamorph/data/sandbox.py

@@ -0,0 +1,95 @@
+"""Stage 4 — run an Opus-authored conversion script in a subprocess.
+
+Trusted-but-buggy execution: a timeout and (POSIX) CPU limit guard against
+runaway scripts. We intentionally do not cap virtual memory (RLIMIT_AS),
+because pandas/numpy reserve large virtual address space and would crash.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+import tempfile
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+DEFAULT_TIMEOUT_SEC = 15.0
+DEFAULT_CPU_SECONDS = 15
+
+
+@dataclass(frozen=True)
+class SandboxResult:
+    output_text: str
+    returncode: int
+    stderr: str
+    elapsed_sec: float
+    error_kind: str  # "ok" | "syntax" | "runtime" | "timeout" | "empty_output"
+
+    @property
+    def ok(self) -> bool:
+        return self.error_kind == "ok"
+
+
+def _posix_limits(cpu_seconds: int):
+    def _apply() -> None:
+        import resource
+
+        resource.setrlimit(resource.RLIMIT_CPU, (cpu_seconds, cpu_seconds))
+
+    return _apply
+
+
+def run_script(
+    script: str,
+    input_path: Path,
+    *,
+    output_suffix: str,
+    timeout_sec: float = DEFAULT_TIMEOUT_SEC,
+    cpu_seconds: int = DEFAULT_CPU_SECONDS,
+) -> SandboxResult:
+    """Write `script` to a temp dir, run it on `input_path`, return the output."""
+
+    input_path = Path(input_path).resolve()
+    with tempfile.TemporaryDirectory() as tmp:
+        tmpdir = Path(tmp)
+        script_path = tmpdir / "convert.py"
+        out_path = tmpdir / f"output{output_suffix}"
+        script_path.write_text(script, encoding="utf-8")
+
+        preexec = _posix_limits(cpu_seconds) if os.name == "posix" else None
+        start = time.perf_counter()
+        try:
+            proc = subprocess.run(
+                [sys.executable, str(script_path), str(input_path), str(out_path)],
+                capture_output=True,
+                text=True,
+                timeout=timeout_sec,
+                cwd=str(tmpdir),
+                preexec_fn=preexec,
+            )
+        except subprocess.TimeoutExpired:
+            return SandboxResult(
+                output_text="",
+                returncode=-1,
+                stderr=f"Timed out after {timeout_sec}s",
+                elapsed_sec=time.perf_counter() - start,
+                error_kind="timeout",
+            )
+        elapsed = time.perf_counter() - start
+
+        if proc.returncode != 0:
+            syntax_markers = ("SyntaxError", "IndentationError", "TabError")
+            kind = (
+                "syntax" if any(m in proc.stderr for m in syntax_markers) else "runtime"
+            )
+            return SandboxResult("", proc.returncode, proc.stderr, elapsed, kind)
+
+        if not out_path.exists():
+            return SandboxResult("", 0, proc.stderr, elapsed, "empty_output")
+        output_text = out_path.read_text(encoding="utf-8")
+        if not output_text.strip():
+            return SandboxResult(output_text, 0, proc.stderr, elapsed, "empty_output")
+
+        return SandboxResult(output_text, 0, proc.stderr, elapsed, "ok")