Rerun any night exactly as production saw it.

import os
import sys
from datetime import date
 
import polars as pl
 
from research import grid, strategy  # your code
 
LAKE = "/mnt/lake"
RUNS = "/mnt/research/runs"
 
 
def run_task(run: str, task: int) -> None:
    """One point in the parameter grid. Every task
    reads the same bars; only the parameters change."""
    bars = (
        pl.scan_parquet(f"{LAKE}/bars/1m/**/*.parquet",
                        hive_partitioning=True)
        .filter(pl.col("date").is_between(
            date(2021, 1, 4), date(2026, 11, 4)))
    )
    pnl = strategy(bars, grid()[task]).collect()
 
    tmp = f"{RUNS}/.{run}.tmp"
    os.makedirs(tmp, exist_ok=True)
    pnl.write_parquet(f"{tmp}/part-{task:04d}.parquet")
 
 
def publish(run: str) -> None:
    """After the Job completes: one atomic rename."""
    os.rename(f"{RUNS}/.{run}.tmp", f"{RUNS}/{run}")
 
 
if __name__ == "__main__":  # python -m sweep run-42
    run_task(sys.argv[1],
             int(os.environ["JOB_COMPLETION_INDEX"]))

# Production, after the nightly batch: freeze the disk
archil checkpoints create /mnt/prod eod-2026-11-04
 
# Weeks later: a writable branch from that night
archil branches --region aws-us-east-1 create dsk-XXXXXXXXXXXX \
    asof-2026-11-04 --from-checkpoint eod-2026-11-04
 
# Mount it anywhere and rerun against it
sudo archil mount myorg/prod /mnt/asof \
    --region aws-us-east-1 --branch asof-2026-11-04

import polars as pl
import yaml
 
from research import signal  # your code
 
ASOF = "/mnt/asof"  # production's disk, as of Nov 4
 
# Rerun November 4 against exactly the features and
# config production had that night
config = yaml.safe_load(open(f"{ASOF}/config/live.yaml"))
features = pl.scan_parquet(
    f"{ASOF}/features/date=2026-11-04/*.parquet")
rerun = signal(features, config).collect()
 
original = pl.read_parquet(f"{ASOF}/signals/2026-11-04.parquet")
print("same output:", rerun.equals(original))