from __future__ import annotations import argparse import json from pathlib import Path import pandas as pd import pytest import casuallab.cli as cli_module from casuallab.cli import ( _run_reproduce, _write_hte_artifacts, build_parser, main, write_simulation_outputs, ) from casuallab.config import DesignConfig, SimulationConfig from casuallab.simulator import simulate_market def test_cli_exposes_required_workflow_commands() -> None: parser = build_parser() actions = [action for action in parser._actions if action.dest == "command"] assert len(actions) == 1 commands = set(actions[0].choices) assert { "download-sample", "build-panel", "validate-nyc-full", "simulate", "benchmark", "interference-benchmark", "nyc-simulation-anchor", "nyc-weather", "nyc-events", "nyc-income", "nyc-benchmark", "nyc-graph-benchmark", "equilibrium-benchmark", "report", "reproduce-sample", }.issubset(commands) report_args = parser.parse_args(["report"]) reproduce_args = parser.parse_args(["reproduce-sample"]) assert report_args.nyc_full_validation == "artifacts/nyc_full/validation.json" assert report_args.nyc_full_manifest == "artifacts/nyc_full/manifest.json" assert ( report_args.treatment_version_policy == "artifacts/benchmarks/treatment_version_policy_results.csv" ) assert ( report_args.treatment_version_policy_manifest == "artifacts/benchmarks/treatment_version_policy_manifest.json" ) assert reproduce_args.nyc_full_validation == "artifacts/nyc_full/validation.json" assert reproduce_args.nyc_full_manifest == "artifacts/nyc_full/manifest.json" assert report_args.interference_summary.endswith("interference_summary.csv") assert report_args.interference_manifest.endswith("interference_manifest.json") assert report_args.nyc_simulation_anchor.endswith("nyc_simulation_anchor.json") assert report_args.nyc_simulation_anchor_manifest.endswith("manifest.json") assert report_args.nyc_benchmark_manifest.endswith("nyc_informed/manifest.json") assert report_args.nyc_graph_benchmark_manifest.endswith("nyc_graph/manifest.json") assert report_args.equilibrium_manifest.endswith("equilibrium/manifest.json") assert report_args.nyc_weather_manifest.endswith("weather/manifest.json") assert report_args.nyc_events_manifest.endswith("events/manifest.json") assert report_args.nyc_income_manifest.endswith("income/manifest.json") weather_args = parser.parse_args(["nyc-weather"]) assert weather_args.raw.endswith("noaa_central_park_2024-01.csv") assert weather_args.data_manifest == "data/nyc_full/manifest.json" event_args = parser.parse_args(["nyc-events"]) assert event_args.events.endswith("nyc_permitted_events_overlap_2024-01.csv") assert event_args.holidays.endswith("official_holidays_2024-01.csv") income_args = parser.parse_args(["nyc-income"]) assert income_args.taxi_zones.endswith("taxi_zones.zip") assert income_args.acs_b19001.endswith("acs_2022_5yr_b19001_nyc_tracts.dat") assert parser.parse_args(["nyc-benchmark"]).replications == 6 assert parser.parse_args(["nyc-graph-benchmark"]).n_zones == 16 assert parser.parse_args(["equilibrium-benchmark"]).treatment_version == "bundled" def test_nyc_weather_command_reuses_pinned_raw_and_writes_bundle( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: raw = tmp_path / "weather.csv" raw.write_text("pinned\n", encoding="utf-8") generated = tuple(tmp_path / f"weather-{index}.csv" for index in range(5)) for path in generated: path.write_text("ok\n", encoding="utf-8") observed: dict[str, object] = {} def download(path: str, *, refresh: bool) -> Path: observed["download"] = (path, refresh) return raw def write_bundle( raw_path: Path, panel_dir: str, data_manifest: str, output_dir: str, *, project_root: Path, ) -> object: observed["writer"] = ( raw_path, panel_dir, data_manifest, output_dir, project_root, ) return argparse.Namespace(paths=lambda: generated) monkeypatch.setattr(cli_module, "download_noaa_daily_weather", download) monkeypatch.setattr(cli_module, "write_nyc_weather_bundle", write_bundle) outputs = cli_module._run_nyc_weather( argparse.Namespace( raw=str(raw), panel_dir="panel", data_manifest="data-manifest.json", output_dir="weather-output", refresh=False, ) ) assert outputs == list(generated) assert observed["download"] == (str(raw), False) assert observed["writer"][0] == raw def test_nyc_events_and_income_commands_use_pinned_inputs( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: generated = tuple(tmp_path / f"artifact-{index}.csv" for index in range(7)) for path in generated: path.write_text("ok\n", encoding="utf-8") observed: dict[str, object] = {} def download(path: str, *, refresh: bool) -> Path: observed["event_download"] = (path, refresh) return Path(path) def event_writer(*args: object, project_root: Path) -> object: observed["event_writer"] = (*args, project_root) return argparse.Namespace(paths=lambda: generated) def income_writer(*args: object, project_root: Path) -> object: observed["income_writer"] = (*args, project_root) return argparse.Namespace(paths=lambda: generated) monkeypatch.setattr(cli_module, "download_nyc_permitted_events_snapshot", download) monkeypatch.setattr(cli_module, "write_nyc_events_bundle", event_writer) monkeypatch.setattr(cli_module, "write_nyc_income_bundle", income_writer) event_outputs = cli_module._run_nyc_events( argparse.Namespace( holidays="holidays.csv", events="events.csv", panel_dir="panel", data_manifest="manifest.json", output_dir="event-output", refresh=False, ) ) income_outputs = cli_module._run_nyc_income( argparse.Namespace( taxi_zones="taxi.zip", nta="nta.geojson", tract_to_nta="tract.csv", acs_b19001="acs.dat", panel_dir="panel", data_manifest="manifest.json", output_dir="income-output", ) ) assert event_outputs == list(generated) assert income_outputs == list(generated) assert observed["event_download"] == ("events.csv", False) assert observed["event_writer"][:5] == ( "holidays.csv", Path("events.csv"), "panel", "manifest.json", "event-output", ) assert observed["income_writer"][:7] == ( "taxi.zip", "nta.geojson", "tract.csv", "acs.dat", "panel", "manifest.json", "income-output", ) def test_offline_enrichment_gate_distinguishes_absent_partial_and_complete( tmp_path: Path, ) -> None: nyc_manifest = tmp_path / "manifest.json" panel = tmp_path / "panel" source_a = tmp_path / "source-a.csv" source_b = tmp_path / "source-b.csv" assert ( cli_module._offline_enrichment_ready( "fixture", nyc_dependencies=(nyc_manifest, panel), external_sources=(source_a, source_b), ) is False ) nyc_manifest.write_text("{}", encoding="utf-8") with pytest.raises(ValueError, match="complete NYC dependencies"): cli_module._offline_enrichment_ready( "fixture", nyc_dependencies=(nyc_manifest, panel), external_sources=(source_a, source_b), ) panel.mkdir() assert ( cli_module._offline_enrichment_ready( "fixture", nyc_dependencies=(nyc_manifest, panel), external_sources=(source_a, source_b), ) is False ) source_a.write_text("a", encoding="utf-8") with pytest.raises(ValueError, match="every pinned external source"): cli_module._offline_enrichment_ready( "fixture", nyc_dependencies=(nyc_manifest, panel), external_sources=(source_a, source_b), ) source_b.write_text("b", encoding="utf-8") assert cli_module._offline_enrichment_ready( "fixture", nyc_dependencies=(nyc_manifest, panel), external_sources=(source_a, source_b), ) def test_cli_help_exits_successfully(capsys: pytest.CaptureFixture[str]) -> None: with pytest.raises(SystemExit) as raised: main(["--help"]) assert raised.value.code == 0 assert "reproduce-sample" in capsys.readouterr().out def test_full_data_requires_explicit_build_opt_in_and_cannot_reproduce( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: config_path = tmp_path / "full.yaml" config_path.write_text( "\n".join( [ "source: nyc_hvfhv", "mode: full", f"project_root: {tmp_path}", "raw_dir: raw", "clean_dir: clean", "panel_dir: panel", "nyc_months: [1]", ] ), encoding="utf-8", ) def unexpected_pipeline(*_args: object, **_kwargs: object) -> object: raise AssertionError("full pipeline ran before explicit opt-in") monkeypatch.setattr(cli_module, "run_data_pipeline", unexpected_pipeline) with pytest.raises(ValueError, match="--allow-full-download"): main(["build-panel", "--config", str(config_path)]) with pytest.raises(ValueError, match="--allow-full-download"): main(["validate-nyc-full", "--config", str(config_path)]) args = argparse.Namespace( output_root=str(tmp_path / "artifacts"), config=str(config_path), simulation_config="configs/simulation.yaml", benchmark_config="configs/benchmark.yaml", policy_config="configs/policy.yaml", refresh=False, ) with pytest.raises(ValueError, match="bounded mode: sample"): _run_reproduce(args) assert not (tmp_path / "artifacts/REPRODUCE_INCOMPLETE.json").exists() def test_validate_nyc_full_publishes_empirical_calibration_bundle( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: config = argparse.Namespace( source="nyc_hvfhv", mode="full", raw_dir=tmp_path / "raw", ) config.raw_dir.mkdir() data_manifest = tmp_path / "data-manifest.json" diagnostics = tmp_path / "diagnostics.json" analysis_file = tmp_path / "analysis.json" calibration_file = tmp_path / "calibration.json" for path in (data_manifest, diagnostics, analysis_file, calibration_file): path.write_text("{}\n", encoding="utf-8") data_artifacts = argparse.Namespace( raw_files=(), diagnostics_path=diagnostics, manifest_path=data_manifest, ) analysis = argparse.Namespace(paths=lambda: (analysis_file,)) calibration = argparse.Namespace(paths=lambda: (calibration_file,)) monkeypatch.setattr(cli_module, "load_data_config", lambda _path: config) monkeypatch.setattr(cli_module, "nyc_hvfhv_urls", lambda _config: ()) monkeypatch.setattr(cli_module, "run_data_pipeline", lambda *_args, **_kwargs: data_artifacts) monkeypatch.setattr(cli_module, "write_nyc_full_analysis", lambda *_args, **_kwargs: analysis) observed_output: list[Path] = [] def write_calibration(_config: object, output: Path) -> object: observed_output.append(output) return calibration monkeypatch.setattr(cli_module, "write_nyc_calibration_bundle", write_calibration) outputs = cli_module._run_validate_nyc_full( argparse.Namespace( config="configs/full.yaml", output_dir=str(tmp_path / "artifacts"), refresh=False, allow_full_download=True, ) ) assert observed_output == [tmp_path / "artifacts/calibration_network"] assert calibration_file in outputs def test_simulation_writer_uses_strict_json_for_unavailable_truth(tmp_path: Path) -> None: config = SimulationConfig( n_zones=3, n_periods=8, spillover_strength=0.2, persistence=0.3, design=DesignConfig(name="geo_cluster", n_clusters=3, seed=8), seed=7, ) outputs = write_simulation_outputs(simulate_market(config), tmp_path) metadata_text = outputs["metadata"].read_text(encoding="utf-8") metadata = json.loads(metadata_text) assert ": NaN" not in metadata_text assert metadata["ground_truth"]["direct_effect"] is None assert metadata["ground_truth"]["intent_to_treat"] is None assert all(path.is_file() for path in outputs.values()) def test_hte_artifact_uses_cluster_holdout_and_known_matching_truth(tmp_path: Path) -> None: outputs = _write_hte_artifacts( SimulationConfig(n_zones=4, n_periods=16, seed=19), tmp_path, ) summary = json.loads(outputs["summary"].read_text(encoding="utf-8")) assert summary["target_estimand"] == "controlled_zone_direct_effect" assert summary["crossfit_group"] == "geographic_randomization_cluster" assert summary["interference"] == 0.0 assert summary["persistence"] == 0.0 assert summary["rows"] == 8 * 16 calibration = pd.read_csv(outputs["calibration"]) assert { "mean_predicted_cate", "mean_known_truth", "mean_error", "rmse", "rows", }.issubset(calibration.columns) subgroup = pd.read_csv(outputs["subgroup_recovery"]) assert {"mean_predicted_cate", "mean_known_truth", "mean_error"}.issubset( subgroup.columns ) stability = pd.read_csv(outputs["fold_stability"]) assert stability["crossfit_fold"].nunique() == 4 assert outputs["calibration_chart"].read_text(encoding="utf-8").startswith("") assert all(path.is_file() for path in outputs.values()) def test_reproduce_marker_invalidates_old_manifest_and_survives_failure( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: output_root = tmp_path / "artifacts" output_root.mkdir() old_manifest = output_root / "reproduce_manifest.json" old_manifest.write_text("{}", encoding="utf-8") def fail(_args: argparse.Namespace) -> list[Path]: raise RuntimeError("synthetic failure") monkeypatch.setattr(cli_module, "_run_reproduce_inner", fail) args = argparse.Namespace( output_root=str(output_root), config="configs/sample.yaml", simulation_config="configs/simulation.yaml", benchmark_config="configs/benchmark.yaml", policy_config="configs/policy.yaml", ) with pytest.raises(RuntimeError, match="synthetic failure"): _run_reproduce(args) assert not old_manifest.exists() marker = output_root / "REPRODUCE_INCOMPLETE.json" assert marker.is_file() assert json.loads(marker.read_text(encoding="utf-8"))["status"] == "incomplete" def test_reproduce_marker_is_removed_only_after_final_manifest( tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: output_root = tmp_path / "artifacts" def succeed(args: argparse.Namespace) -> list[Path]: manifest = Path(args.output_root) / "reproduce_manifest.json" manifest.write_text('{"files": []}', encoding="utf-8") return [manifest] monkeypatch.setattr(cli_module, "_run_reproduce_inner", succeed) args = argparse.Namespace( output_root=str(output_root), config="configs/sample.yaml", simulation_config="configs/simulation.yaml", benchmark_config="configs/benchmark.yaml", policy_config="configs/policy.yaml", ) outputs = _run_reproduce(args) assert outputs == [output_root / "reproduce_manifest.json"] assert not (output_root / "REPRODUCE_INCOMPLETE.json").exists()