#!/usr/bin/env python3 """Generate tracked SmartGridBench experiment config cohorts. This script is intentionally broad. The paper evidence registry decides which runs graduate to claim-grade evidence; this generator makes the experimental space reproducible before scarce compute or hosted access disappears. """ from __future__ import annotations import argparse import csv from dataclasses import dataclass, field from pathlib import Path ROOT = Path(__file__).resolve().parent.parent OUT_ROOT = ROOT / "configs" / "config_universe" GENERATED_ROOT = OUT_ROOT / "generated" COHORT_ROOT = OUT_ROOT / "cohorts" CATALOG_PATH = OUT_ROOT / "catalog.tsv" JUDGE_MODEL = "watsonx/meta-llama/llama-4-maverick-17b-128e-instruct-fp8" WATSONX_70B_MODEL = "watsonx/meta-llama/llama-3-3-70b-instruct" FINAL6 = [ "data/scenarios/multi_01_end_to_end_fault_response.json", "data/scenarios/multi_02_dga_to_workorder_pipeline.json", "data/scenarios/fmsr_04_dga_full_diagnostic_chain.json", "data/scenarios/iot_04_load_current_overload_check.json", "data/scenarios/tsfm_02_hotspot_temp_anomaly.json", "data/scenarios/wo_04_fault_record_downtime_update.json", ] @dataclass(frozen=True) class ScenarioSet: key: str name: str files: tuple[str, ...] scope: str @dataclass(frozen=True) class Method: label: str source: str cell: str family: str group: str description: str overrides: dict[str, str] = field(default_factory=dict) hosted_70b: bool = False pe_family: bool = False @dataclass(frozen=True) class ConfigItem: cohort: str label: str source: str cell: str family: str scenario_set: ScenarioSet trials: int description: str overrides: dict[str, str] tags: tuple[str, ...] @property def rel_path(self) -> Path: safe_label = self.label.lower().replace("+", "p").replace("/", "_") return ( Path("configs") / "config_universe" / "generated" / self.cohort / f"{safe_label}.env" ) def scenario_files(pattern: str) -> tuple[str, ...]: return tuple( sorted( path.relative_to(ROOT).as_posix() for path in (ROOT / "data" / "scenarios").glob(pattern) ) ) def scenario_sets() -> dict[str, ScenarioSet]: all31 = tuple( sorted( path.relative_to(ROOT).as_posix() for path in (ROOT / "data" / "scenarios").glob("*.json") if path.is_file() ) ) return { "smoke1": ScenarioSet( "smoke1", "smartgrid_smoke1_v1", ("data/scenarios/multi_01_end_to_end_fault_response.json",), "smoke_single", ), "final6": ScenarioSet( "final6", "smartgrid_final6_v1", tuple(FINAL6), "mixed_final6" ), "all31": ScenarioSet("all31", "smartgrid_all31_v1", all31, "all31_canonical"), "generated5": ScenarioSet( "generated5", "smartgrid_generated_review5_20260503", scenario_files("generated/first_review_20260503/SGT-GEN-*.json"), "generated_review", ), "multi7": ScenarioSet( "multi7", "smartgrid_multi7_v1", scenario_files("multi_*.json"), "multi_domain", ), "fmsr7": ScenarioSet( "fmsr7", "smartgrid_fmsr7_v1", tuple( sorted( scenario_files("fmsr_*.json") + scenario_files("aob_fmsr_*.json") ) ), "fmsr", ), "iot6": ScenarioSet( "iot6", "smartgrid_iot6_v1", scenario_files("iot_*.json"), "iot" ), "tsfm5": ScenarioSet( "tsfm5", "smartgrid_tsfm5_v1", scenario_files("tsfm_*.json"), "tsfm" ), "wo6": ScenarioSet( "wo6", "smartgrid_wo6_v1", scenario_files("wo_*.json"), "wo" ), } def model_optimized_overrides(context_len: int = 8192) -> dict[str, str]: return { "MODEL_ID": "openai/Llama-3.1-8B-Instruct-int8", "MODEL_PROVIDER": "vllm", "SERVING_STACK": "insomnia_vllm", "QUANTIZATION_MODE": "compressed-tensors-int8-bf16-fp8kv", "MAX_MODEL_LEN": str(context_len), "MAX_TOKENS": "1024", "LAUNCH_VLLM": "1", "VLLM_MODEL_PATH": "models/Llama-3.1-8B-Instruct-int8", "VLLM_SERVED_MODEL_NAME": "Llama-3.1-8B-Instruct-int8", "VLLM_DTYPE": "bfloat16", "VLLM_STARTUP_TIMEOUT": "1200", "EXTRA_VLLM_ARGS": "--quantization compressed-tensors --kv-cache-dtype fp8 --enable-prefix-caching", "AAT_MCP_CLIENT_TIMEOUT_SECONDS": "120", } def hosted_70b_overrides() -> dict[str, str]: return { "MODEL_ID": WATSONX_70B_MODEL, "MODEL_PROVIDER": "watsonx", "SERVING_STACK": "watsonx_api", "QUANTIZATION_MODE": "provider_managed_fp8", "LAUNCH_VLLM": "0", "TORCH_PROFILE": "0", "ENABLE_WANDB": "0", "WANDB_MODE": "offline", "EXTRA_VLLM_ARGS": "", "AAT_MCP_SERVER_LAUNCH_MODE": "uv", "AAT_MCP_CLIENT_TIMEOUT_SECONDS": "180", "AAT_PARALLEL_TOOL_CALLS": "false", "PLAN_EXECUTE_REPO_LOCAL": "1", "JUDGE_MODEL": JUDGE_MODEL, } def pe_method( label: str, source: str, cell: str, description: str, *, transport: bool = False, model_optimized: bool = False, ) -> Method: overrides: dict[str, str] = {} if transport: overrides.update( { "MCP_MODE": "optimized", "PLAN_EXECUTE_REPO_LOCAL": "1", "AAT_MCP_CLIENT_TIMEOUT_SECONDS": "120", } ) if model_optimized: overrides.update(model_optimized_overrides()) return Method( label=label, source=source, cell=cell, family="config_universe_local8b", group="pe_family", description=description, overrides=overrides, hosted_70b=not model_optimized, pe_family=True, ) def local_methods() -> list[Method]: methods = [ Method( "AT_I", "configs/aat_direct.env", "AT_I", "config_universe_local8b", "aat", "AaT direct Python tools", hosted_70b=True, ), Method( "AT_M", "configs/aat_mcp_baseline.env", "AT_M", "config_universe_local8b", "aat", "AaT MCP baseline transport", hosted_70b=True, ), Method( "AT_T", "configs/aat_mcp_optimized.env", "AT_T", "config_universe_local8b", "aat", "AaT optimized MCP transport plus prefix caching", hosted_70b=True, ), Method( "AT_D", "configs/aat_mcp_model_optimized.env", "AT_D", "config_universe_local8b", "aat", "AaT optimized MCP plus local INT8/BF16/fp8KV serving", ), ] y = "configs/experiment2/exp2_cell_Y_pe_mcp_baseline.env" ys = "configs/experiment2/exp2_cell_Y_pe_self_ask_mcp_baseline.env" z = "configs/experiment2/exp2_cell_Z_verified_pe_mcp_baseline.env" zs = "configs/experiment2/exp2_cell_Z_verified_pe_self_ask_mcp_baseline.env" methods.extend( [ pe_method("PE_M", y, "PE_M", "Plan-Execute MCP baseline"), pe_method( "PE_S_M", ys, "PE_S_M", "Plan-Execute plus Self-Ask on MCP baseline" ), pe_method( "PE_T", y, "PE_T", "Plan-Execute optimized MCP transport", transport=True, ), pe_method( "PE_S_T", ys, "PE_S_T", "Plan-Execute plus Self-Ask with optimized MCP transport", transport=True, ), pe_method( "PE_D", y, "PE_D", "Plan-Execute with local INT8/BF16/fp8KV serving", model_optimized=True, ), pe_method( "PE_S_D", ys, "PE_S_D", "Plan-Execute plus Self-Ask with local INT8/BF16/fp8KV serving", model_optimized=True, ), pe_method( "PE_TD", y, "PE_TD", "Plan-Execute optimized MCP plus local INT8/BF16/fp8KV serving", transport=True, model_optimized=True, ), pe_method( "PE_S_TD", ys, "PE_S_TD", "Plan-Execute plus Self-Ask, optimized MCP, and local INT8/BF16/fp8KV serving", transport=True, model_optimized=True, ), pe_method("V_M", z, "V_M", "Verified PE MCP baseline"), pe_method( "V_S_M", zs, "V_S_M", "Verified PE plus Self-Ask on MCP baseline" ), pe_method( "V_T", z, "V_T", "Verified PE optimized MCP transport", transport=True ), pe_method( "V_S_T", zs, "V_S_T", "Verified PE plus Self-Ask with optimized MCP transport", transport=True, ), pe_method( "V_D", z, "V_D", "Verified PE with local INT8/BF16/fp8KV serving", model_optimized=True, ), pe_method( "V_S_D", zs, "V_S_D", "Verified PE plus Self-Ask with local INT8/BF16/fp8KV serving", model_optimized=True, ), pe_method( "V_TD", z, "V_TD", "Verified PE optimized MCP plus local INT8/BF16/fp8KV serving", transport=True, model_optimized=True, ), pe_method( "V_S_TD", zs, "V_S_TD", "Verified PE plus Self-Ask, optimized MCP, and local INT8/BF16/fp8KV serving", transport=True, model_optimized=True, ), ] ) return methods MITIGATION_RUNGS: tuple[tuple[str, str, dict[str, str]], ...] = ( ("BASELINE", "no mitigation flags", {}), ("GUARD", "missing-evidence detector only", {"ENABLE_MISSING_EVIDENCE_GUARD": "1"}), ( "REPAIR", "missing-evidence detector plus retry/replan repair", { "ENABLE_MISSING_EVIDENCE_GUARD": "1", "ENABLE_MISSING_EVIDENCE_REPAIR": "1", "MISSING_EVIDENCE_REPAIR_MAX_ATTEMPTS": "2", "MISSING_EVIDENCE_REPAIR_MAX_ATTEMPTS_PER_TARGET": "1", }, ), ( "ADJ", "repair plus explicit fault/risk adjudication", { "ENABLE_MISSING_EVIDENCE_GUARD": "1", "ENABLE_MISSING_EVIDENCE_REPAIR": "1", "ENABLE_EXPLICIT_FAULT_RISK_ADJUDICATION": "1", "MISSING_EVIDENCE_REPAIR_MAX_ATTEMPTS": "2", "MISSING_EVIDENCE_REPAIR_MAX_ATTEMPTS_PER_TARGET": "1", }, ), ) def shell_quote(value: str) -> str: escaped = ( value.replace("\\", "\\\\") .replace('"', '\\"') .replace("$", "\\$") .replace("`", "\\`") ) return f'"{escaped}"' def write_config(item: ConfigItem) -> None: out_path = ROOT / item.rel_path out_path.parent.mkdir(parents=True, exist_ok=True) experiment_name = f"{item.cohort}_{item.label}".lower() experiment_name = experiment_name.replace("+", "p").replace("/", "_") merged = { "EXPERIMENT_NAME": experiment_name, "EXPERIMENT_CELL": item.cell, "EXPERIMENT_FAMILY": item.family, "SCENARIO_SET_NAME": item.scenario_set.name, "SCENARIOS_GLOB": " ".join(item.scenario_set.files), "TRIALS": str(item.trials), "SCENARIO_DOMAIN_SCOPE": item.scenario_set.scope, "CONTRIBUTING_EXPERIMENTS": ",".join(item.tags), "TORCH_PROFILE": "0", "SMARTGRID_RESUME_REQUIRE_LATENCY": "1", } merged.update(item.overrides) lines = [ "# Generated by scripts/generate_config_universe.py. Do not edit by hand.", f"# Cohort: {item.cohort}", f"# Row: {item.label}", f"# Description: {item.description}", f"source {item.source}", "", ] for key in sorted(merged): lines.append(f"{key}={shell_quote(merged[key])}") out_path.write_text("\n".join(lines) + "\n", encoding="utf-8") def add_method_configs( items: list[ConfigItem], *, cohort: str, methods: list[Method], scenario_set: ScenarioSet, trials: int, tags: tuple[str, ...], hosted_70b: bool = False, ) -> None: for method in methods: overrides = dict(method.overrides) family = method.family cell = method.cell label = method.label description = method.description if hosted_70b: if not method.hosted_70b: continue overrides.update(hosted_70b_overrides()) family = "config_universe_watsonx70b" cell = f"{method.cell}70B" label = f"{method.label}70B" description = f"Hosted WatsonX 70B variant of {method.description}" items.append( ConfigItem( cohort=cohort, label=label, source=method.source, cell=cell, family=family, scenario_set=scenario_set, trials=trials, description=description, overrides=overrides, tags=tags, ) ) def add_mitigation_configs( items: list[ConfigItem], *, cohort: str, methods: list[Method], scenario_set: ScenarioSet, trials: int, hosted_70b: bool = False, ) -> None: for method in methods: if not method.pe_family: continue if hosted_70b and not method.hosted_70b: continue base_overrides = dict(method.overrides) family = "config_universe_mitigation" cell_prefix = method.cell label_prefix = method.label description_prefix = method.description if hosted_70b: base_overrides.update(hosted_70b_overrides()) family = "config_universe_watsonx70b_mitigation" cell_prefix = f"{method.cell}70B" label_prefix = f"{method.label}70B" description_prefix = f"Hosted WatsonX 70B variant of {method.description}" for rung, rung_desc, rung_overrides in MITIGATION_RUNGS: overrides = dict(base_overrides) overrides.update(rung_overrides) label = f"{label_prefix}_{rung}" items.append( ConfigItem( cohort=cohort, label=label, source=method.source, cell=f"{cell_prefix}_{rung}", family=family, scenario_set=scenario_set, trials=trials, description=f"{description_prefix}; mitigation rung {rung}: {rung_desc}", overrides=overrides, tags=( "config_universe", "failure_mitigation", "full_cross_product", ), ) ) def add_context_configs( items: list[ConfigItem], *, cohort: str, methods: list[Method], scenario_set: ScenarioSet, trials: int, ) -> None: for method in methods: for context_len in (8192, 16384, 32768): overrides = dict(method.overrides) overrides["MAX_MODEL_LEN"] = str(context_len) if "int8" in overrides.get("MODEL_ID", ""): overrides.update(model_optimized_overrides(context_len)) label = f"{method.label}_{context_len // 1024}K" items.append( ConfigItem( cohort=cohort, label=label, source=method.source, cell=f"{method.cell}_{context_len // 1024}K", family="config_universe_context_ablation", scenario_set=scenario_set, trials=trials, description=f"{method.description}; context-window ablation at {context_len}", overrides=overrides, tags=("config_universe", "context_ablation", "full_cross_product"), ) ) def add_repair_depth_configs( items: list[ConfigItem], *, cohort: str, methods: list[Method], scenario_set: ScenarioSet, trials: int, ) -> None: selected = { method.label for method in methods if method.label in {"PE_S_M", "PE_S_T", "V_S_M", "V_S_T"} } for method in methods: if method.label not in selected: continue for attempts in (1, 2, 3): for rung in ("REPAIR", "ADJ"): overrides = dict(method.overrides) overrides.update( { "ENABLE_MISSING_EVIDENCE_GUARD": "1", "ENABLE_MISSING_EVIDENCE_REPAIR": "1", "MISSING_EVIDENCE_REPAIR_MAX_ATTEMPTS": str(attempts), "MISSING_EVIDENCE_REPAIR_MAX_ATTEMPTS_PER_TARGET": "1", } ) if rung == "ADJ": overrides["ENABLE_EXPLICIT_FAULT_RISK_ADJUDICATION"] = "1" label = f"{method.label}_{rung}_R{attempts}" items.append( ConfigItem( cohort=cohort, label=label, source=method.source, cell=f"{method.cell}_{rung}_R{attempts}", family="config_universe_repair_depth_ablation", scenario_set=scenario_set, trials=trials, description=f"{method.description}; {rung.lower()} with {attempts} repair attempts", overrides=overrides, tags=("config_universe", "mitigation_repair_depth_ablation"), ) ) def add_temperature_configs( items: list[ConfigItem], *, cohort: str, methods: list[Method], scenario_set: ScenarioSet, trials: int, ) -> None: selected = {"AT_I", "AT_M", "AT_T", "PE_M", "PE_S_M", "V_M", "V_S_M"} for method in methods: if method.label not in selected: continue for temp in ("0.2", "0.7"): overrides = dict(method.overrides) overrides["TEMPERATURE"] = temp label = f"{method.label}_TEMP{temp.replace('.', '')}" items.append( ConfigItem( cohort=cohort, label=label, source=method.source, cell=f"{method.cell}_T{temp.replace('.', '')}", family="config_universe_decoding_ablation", scenario_set=scenario_set, trials=trials, description=f"{method.description}; decoding temperature {temp}", overrides=overrides, tags=("config_universe", "decoding_ablation"), ) ) def build_items() -> list[ConfigItem]: sets = scenario_sets() methods = local_methods() items: list[ConfigItem] = [] add_method_configs( items, cohort="local_smoke1x1_full", methods=methods, scenario_set=sets["smoke1"], trials=1, tags=("config_universe", "smoke", "local8b"), ) add_method_configs( items, cohort="local_all31x5_full", methods=methods, scenario_set=sets["all31"], trials=5, tags=("config_universe", "local8b", "full_cross_product"), ) add_method_configs( items, cohort="local_generated5x5_full", methods=methods, scenario_set=sets["generated5"], trials=5, tags=("config_universe", "local8b", "generated_scenarios"), ) for key in ("multi7", "fmsr7", "iot6", "tsfm5", "wo6"): add_method_configs( items, cohort=f"local_{key}_5x_full", methods=methods, scenario_set=sets[key], trials=5, tags=("config_universe", "local8b", "domain_slice"), ) add_mitigation_configs( items, cohort="mitigation_all31x5_full", methods=methods, scenario_set=sets["all31"], trials=5, ) add_mitigation_configs( items, cohort="mitigation_generated5x5_full", methods=methods, scenario_set=sets["generated5"], trials=5, ) add_context_configs( items, cohort="context_all31x3_full", methods=methods, scenario_set=sets["all31"], trials=3, ) add_repair_depth_configs( items, cohort="repair_depth_all31x3", methods=methods, scenario_set=sets["all31"], trials=3, ) add_temperature_configs( items, cohort="decoding_all31x3", methods=methods, scenario_set=sets["all31"], trials=3, ) add_method_configs( items, cohort="watsonx70b_smoke1x1_full", methods=methods, scenario_set=sets["smoke1"], trials=1, tags=("config_universe", "smoke", "watsonx70b"), hosted_70b=True, ) add_method_configs( items, cohort="watsonx70b_all31x5_full", methods=methods, scenario_set=sets["all31"], trials=5, tags=("config_universe", "watsonx70b", "full_cross_product"), hosted_70b=True, ) add_method_configs( items, cohort="watsonx70b_generated5x5_full", methods=methods, scenario_set=sets["generated5"], trials=5, tags=("config_universe", "watsonx70b", "generated_scenarios"), hosted_70b=True, ) add_mitigation_configs( items, cohort="watsonx70b_mitigation_all31x5_full", methods=methods, scenario_set=sets["all31"], trials=5, hosted_70b=True, ) add_mitigation_configs( items, cohort="watsonx70b_mitigation_generated5x5_full", methods=methods, scenario_set=sets["generated5"], trials=5, hosted_70b=True, ) return items def clear_generated() -> None: for root in (GENERATED_ROOT, COHORT_ROOT): if root.exists(): for path in sorted(root.rglob("*"), reverse=True): if path.is_file(): path.unlink() elif path.is_dir(): path.rmdir() root.mkdir(parents=True, exist_ok=True) def write_catalog(items: list[ConfigItem]) -> None: CATALOG_PATH.parent.mkdir(parents=True, exist_ok=True) with CATALOG_PATH.open("w", newline="", encoding="utf-8") as f: writer = csv.writer(f, delimiter="\t") writer.writerow( [ "cohort", "label", "config", "runtime_family", "scenario_set", "scenario_count", "trials", "expected_trajectories", "source", "cell", "description", "tags", ] ) for item in sorted(items, key=lambda i: (i.cohort, i.label)): writer.writerow( [ item.cohort, item.label, item.rel_path.as_posix(), item.family, item.scenario_set.name, len(item.scenario_set.files), item.trials, len(item.scenario_set.files) * item.trials, item.source, item.cell, item.description, ",".join(item.tags), ] ) def write_cohorts(items: list[ConfigItem]) -> None: by_cohort: dict[str, list[ConfigItem]] = {} for item in items: by_cohort.setdefault(item.cohort, []).append(item) for cohort, cohort_items in sorted(by_cohort.items()): path = COHORT_ROOT / f"{cohort}.tsv" with path.open("w", encoding="utf-8", newline="") as f: writer = csv.writer(f, delimiter="\t") writer.writerow(["label", "config"]) for item in sorted(cohort_items, key=lambda i: i.label): writer.writerow([item.label, item.rel_path.as_posix()]) def write_readme(items: list[ConfigItem]) -> None: by_cohort: dict[str, list[ConfigItem]] = {} for item in items: by_cohort.setdefault(item.cohort, []).append(item) lines = [ "---", "status: canonical-index", "scope: team-repo", "owner: Team 13", "canonical: true", "---", "", "# Config Universe", "", "Generated SmartGridBench experiment configs for opportunistic compute waves.", "The evidence registry, not this directory, decides which completed runs are paper-grade.", "", "Materialize the per-row `.env` files locally on a VM with:", "", "```bash", "python3 scripts/generate_config_universe.py", "```", "", "This writes ignored files under `configs/config_universe/generated/`. The", "tracked source of truth is the generator plus this directory's `catalog.tsv` and", "`cohorts/*.tsv` manifests. Each cohort TSV has the existing two-column runner", "shape: `label` and `config`, and the `config` paths resolve after local", "materialization.", "", "Check that the tracked manifests are fresh with:", "", "```bash", "python3 scripts/generate_config_universe.py --check", "```", "", "`--check` regenerates in place before comparing tracked manifests. If it", "fails, run the generator normally and inspect the resulting diff.", "", "## Cohorts", "", "| Cohort | Rows | Expected trajectories | Notes |", "|---|---:|---:|---|", ] for cohort, cohort_items in sorted(by_cohort.items()): expected = sum( len(item.scenario_set.files) * item.trials for item in cohort_items ) note = { "local_smoke1x1_full": "one-scenario local 8B smoke for every local method row", "local_all31x5_full": "full local 8B method cross-product over the canonical scenario set", "local_generated5x5_full": "local 8B method cross-product over the latest reviewed generated-scenario batch", "mitigation_all31x5_full": "4-tier mitigation ladder crossed with every PE-family local method", "mitigation_generated5x5_full": "4-tier mitigation ladder over the latest reviewed generated-scenario batch", "context_all31x3_full": "8K/16K/32K context ablations for every local method row", "repair_depth_all31x3": "repair/adjudication depth ablation on the main Self-Ask PE-family rows", "decoding_all31x3": "temperature ablation on core local rows", "watsonx70b_smoke1x1_full": "one-scenario hosted-70B smoke for every hosted-compatible method row", "watsonx70b_all31x5_full": "hosted-70B all-31 core/transport PE-family expansion", "watsonx70b_generated5x5_full": "hosted-70B method cross-product over the latest reviewed generated-scenario batch", "watsonx70b_mitigation_all31x5_full": "hosted-70B mitigation ladder for hosted-compatible PE-family rows", "watsonx70b_mitigation_generated5x5_full": "hosted-70B mitigation ladder over the latest reviewed generated-scenario batch", }.get(cohort, "") if ( cohort.startswith("local_") and cohort.endswith("_5x_full") and "_all31" not in cohort and "_generated" not in cohort ): note = "local 8B method cross-product on one canonical domain slice" lines.append(f"| `{cohort}` | {len(cohort_items)} | {expected} | {note} |") lines.extend( [ "", "## Guardrails", "", "- Run `local_smoke1x1_full` or `watsonx70b_smoke1x1_full` before a new family if access or runner state changed.", "- Preserve raw run directories. Promote only after pullback, count validation, judge rows, and registry review.", "- Hosted WatsonX rows require fresh credentials plus all aliases: `WATSONX_APIKEY`, `WATSONX_API_KEY`, `WX_API_KEY`, `WATSONX_PROJECT_ID`, `WX_PROJECT_ID`, `WATSONX_URL`, `WX_URL`.", "- D/TD local rows require the INT8 model path and FlashInfer build dependencies on the VM.", "", ] ) (OUT_ROOT / "README.md").write_text("\n".join(lines), encoding="utf-8") def main() -> int: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument( "--check", action="store_true", help="regenerate in place and fail if tracked catalog/cohort docs are stale", ) args = parser.parse_args() before: dict[Path, str] = {} if args.check and OUT_ROOT.exists(): for path in OUT_ROOT.rglob("*"): if path.is_relative_to(GENERATED_ROOT): continue if path.is_file(): before[path.relative_to(ROOT)] = path.read_text(encoding="utf-8") items = build_items() clear_generated() for item in items: write_config(item) write_cohorts(items) write_catalog(items) write_readme(items) if args.check: after = { path.relative_to(ROOT): path.read_text(encoding="utf-8") for path in OUT_ROOT.rglob("*") if path.is_file() and not path.is_relative_to(GENERATED_ROOT) } if before != after: print( "ERROR: config-universe tracked manifests are stale. " "Run scripts/generate_config_universe.py." ) return 1 print(f"generated {len(items)} configs in {GENERATED_ROOT.relative_to(ROOT)}") print(f"wrote catalog: {CATALOG_PATH.relative_to(ROOT)}") return 0 if __name__ == "__main__": raise SystemExit(main())