| |
| """Audit upstream dependency accuracy and downstream error propagation. |
| |
| The IJCV revision asks for accuracy, failure modes, and downstream propagation |
| for optional joint-type classifiers (GPT/VLM or KPP head) and segmentation |
| front ends such as P3-SAM. This script intentionally works from locked eval |
| artifacts: it does not rerun inference or alter metric definitions. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import json |
| import math |
| from collections import Counter, defaultdict |
| from pathlib import Path |
| from statistics import mean, median |
| from typing import Dict, Iterable, List, Optional |
|
|
|
|
| BOOL_TRUE = {"true", "1", "yes", "y", "t"} |
|
|
|
|
| def parse_bool(value: object) -> bool: |
| return str(value).strip().lower() in BOOL_TRUE |
|
|
|
|
| def parse_float(value: object) -> Optional[float]: |
| if value is None: |
| return None |
| text = str(value).strip() |
| if not text or text.upper() == "N/A": |
| return None |
| return float(text) |
|
|
|
|
| def read_csv(path: Path) -> List[Dict[str, str]]: |
| with path.open(newline="") as f: |
| return list(csv.DictReader(f)) |
|
|
|
|
| def write_csv(path: Path, rows: List[Dict[str, object]], fieldnames: Iterable[str]) -> None: |
| path.parent.mkdir(parents=True, exist_ok=True) |
| with path.open("w", newline="") as f: |
| writer = csv.DictWriter(f, fieldnames=list(fieldnames)) |
| writer.writeheader() |
| writer.writerows(rows) |
|
|
|
|
| def fmt_ratio(numer: int, denom: int) -> str: |
| pct = 100.0 * numer / denom if denom else 0.0 |
| return f"{numer}/{denom} ({pct:.1f}%)" |
|
|
|
|
| def summarize(values: Iterable[Optional[float]]) -> Dict[str, object]: |
| vals = [float(v) for v in values if v is not None and math.isfinite(float(v))] |
| if not vals: |
| return {"n": 0, "mean": "N/A", "median": "N/A", "max": "N/A"} |
| vals_sorted = sorted(vals) |
| return { |
| "n": len(vals_sorted), |
| "mean": mean(vals_sorted), |
| "median": median(vals_sorted), |
| "max": max(vals_sorted), |
| } |
|
|
|
|
| def fmt_stat(value: object, digits: int = 4) -> str: |
| if isinstance(value, (int, float)): |
| return f"{value:.{digits}f}" |
| return str(value) |
|
|
|
|
| def first_present(row: Dict[str, object], keys: Iterable[str]) -> Optional[str]: |
| for key in keys: |
| if key in row and str(row[key]).strip() != "": |
| return key |
| return None |
|
|
|
|
| def parse_segmentation_rows(segmentation_rows: List[Dict[str, str]]) -> List[Dict[str, object]]: |
| parsed = [] |
| for row in segmentation_rows: |
| iou_key = first_present(row, ["iou", "IoU", "mask_iou", "p3sam_iou"]) |
| precision_key = first_present(row, ["precision", "Precision", "mask_precision"]) |
| recall_key = first_present(row, ["recall", "Recall", "mask_recall"]) |
| parsed.append( |
| { |
| "case_id": str(row.get("case_id", "unknown")), |
| "iou": parse_float(row.get(iou_key)) if iou_key else None, |
| "precision": parse_float(row.get(precision_key)) if precision_key else None, |
| "recall": parse_float(row.get(recall_key)) if recall_key else None, |
| "selection_mode": row.get("selection_mode", ""), |
| "prompt_mode": row.get("prompt_mode", ""), |
| "choose_head": row.get("choose_head", ""), |
| } |
| ) |
| return parsed |
|
|
|
|
| def load_optional_segmentation(path: Optional[Path]) -> Optional[List[Dict[str, str]]]: |
| if path is None: |
| return None |
| if not path.exists(): |
| raise FileNotFoundError(f"Segmentation metrics file not found: {path}") |
| return read_csv(path) |
|
|
|
|
| def load_optional_jsonl(path: Optional[Path]) -> Optional[List[Dict[str, object]]]: |
| if path is None: |
| return None |
| if not path.exists(): |
| raise FileNotFoundError(f"JSONL audit file not found: {path}") |
| rows = [] |
| with path.open() as f: |
| for line in f: |
| text = line.strip() |
| if text: |
| rows.append(json.loads(text)) |
| return rows |
|
|
|
|
| def make_markdown_report( |
| rows: List[Dict[str, object]], |
| segmentation_rows: Optional[List[Dict[str, str]]], |
| llm_audit_rows: Optional[List[Dict[str, object]]], |
| output_csv: Path, |
| ) -> str: |
| n = len(rows) |
| type_correct = sum(bool(row["type_correct"]) for row in rows) |
| strict = sum(bool(row["success_strict"]) for row in rows) |
| relaxed = sum(bool(row["success_relaxed"]) for row in rows) |
| axis_only = sum(bool(row["success_axis_only"]) for row in rows) |
|
|
| type_ok_rows = [row for row in rows if row["type_correct"]] |
| type_bad_rows = [row for row in rows if not row["type_correct"]] |
| axis_outliers = [row for row in rows if (row["axis_error_deg"] or 0.0) >= 45.0] |
| origin_failures = [row for row in rows if (row["origin_error_normalized"] or 0.0) >= 0.05] |
|
|
| confusion = Counter((row["gt_joint_type"], row["pred_joint_type"]) for row in rows) |
| by_category = defaultdict(list) |
| for row in rows: |
| by_category[row["category"]].append(row) |
|
|
| scope_lines = [ |
| "# Dependency Error Propagation Audit", |
| "", |
| "## Scope", |
| "", |
| "- Source metrics: locked GAP-25 DragMesh/KPP evaluation CSV.", |
| "- This audits the automatic KPP joint-type head used in the reported KPP-only setting.", |
| "- GPT/VLM joint classification is optional in `inference_pipeline.py`; no GPT response log was found in the supplied DragMesh artifacts, so GPT-4o accuracy is not inferred here.", |
| ] |
| if segmentation_rows is None: |
| scope_lines.append( |
| "- P3-SAM is optional. No segmentation metrics CSV was supplied, so this report documents mask dependency and propagation risk instead of fabricating P3-SAM accuracy." |
| ) |
| else: |
| scope_lines.append( |
| "- P3-SAM/mask metrics were supplied separately and are treated as an upstream-front-end audit; the locked kinematic CSV itself was measured with provided movable masks." |
| ) |
| scope_lines += [ |
| "", |
| "## Overall Accuracy", |
| "", |
| f"- Cases: `{n}`", |
| f"- Joint type accuracy: `{fmt_ratio(type_correct, n)}`", |
| f"- Strict / relaxed / axis-only success: `{fmt_ratio(strict, n)}` / `{fmt_ratio(relaxed, n)}` / `{fmt_ratio(axis_only, n)}`", |
| f"- Axis error deg mean / median / max: `{fmt_stat(summarize(row['axis_error_deg'] for row in rows)['mean'])}` / `{fmt_stat(summarize(row['axis_error_deg'] for row in rows)['median'])}` / `{fmt_stat(summarize(row['axis_error_deg'] for row in rows)['max'])}`", |
| f"- Origin error mean / median / max: `{fmt_stat(summarize(row['origin_error_normalized'] for row in rows)['mean'])}` / `{fmt_stat(summarize(row['origin_error_normalized'] for row in rows)['median'])}` / `{fmt_stat(summarize(row['origin_error_normalized'] for row in rows)['max'])}`", |
| "", |
| "## Joint-Type Confusion", |
| "", |
| "| GT | Pred | Count |", |
| "| --- | --- | --- |", |
| ] |
| lines = scope_lines |
| for (gt, pred), count in sorted(confusion.items()): |
| lines.append(f"| {gt} | {pred} | {count} |") |
|
|
| lines += [ |
| "", |
| "## Downstream Propagation", |
| "", |
| "| Subset | Count | Strict | Relaxed | Axis-only | Mean final CD | Median final CD | Mean endpoint L2 |", |
| "| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |", |
| ] |
|
|
| for name, subset in [("type correct", type_ok_rows), ("type wrong", type_bad_rows)]: |
| denom = len(subset) |
| final_cd = summarize(row["normalized_traj_cd_final"] for row in subset) |
| endpoint = summarize(row["endpoint_l2_mean"] for row in subset) |
| lines.append( |
| "| " |
| + " | ".join( |
| [ |
| name, |
| str(denom), |
| fmt_ratio(sum(bool(row["success_strict"]) for row in subset), denom), |
| fmt_ratio(sum(bool(row["success_relaxed"]) for row in subset), denom), |
| fmt_ratio(sum(bool(row["success_axis_only"]) for row in subset), denom), |
| fmt_stat(final_cd["mean"]), |
| fmt_stat(final_cd["median"]), |
| fmt_stat(endpoint["mean"]), |
| ] |
| ) |
| + " |" |
| ) |
|
|
| lines += [ |
| "", |
| "## Category Breakdown", |
| "", |
| "| Category | Type Acc | Strict | Relaxed | Axis-only | Mean Axis Deg | Mean Origin |", |
| "| --- | ---: | ---: | ---: | ---: | ---: | ---: |", |
| ] |
| for category in sorted(by_category): |
| subset = by_category[category] |
| denom = len(subset) |
| lines.append( |
| "| " |
| + " | ".join( |
| [ |
| category, |
| fmt_ratio(sum(bool(row["type_correct"]) for row in subset), denom), |
| fmt_ratio(sum(bool(row["success_strict"]) for row in subset), denom), |
| fmt_ratio(sum(bool(row["success_relaxed"]) for row in subset), denom), |
| fmt_ratio(sum(bool(row["success_axis_only"]) for row in subset), denom), |
| fmt_stat(summarize(row["axis_error_deg"] for row in subset)["mean"]), |
| fmt_stat(summarize(row["origin_error_normalized"] for row in subset)["mean"]), |
| ] |
| ) |
| + " |" |
| ) |
|
|
| lines += [ |
| "", |
| "## Failure Modes", |
| "", |
| f"- Type errors: `{len(type_bad_rows)}/{n}`; cases: `{', '.join(row['case_id'] for row in type_bad_rows)}`.", |
| f"- Axis outliers >=45 deg: `{len(axis_outliers)}/{n}`; cases: `{', '.join(row['case_id'] for row in axis_outliers)}`.", |
| f"- Origin errors >=0.05 bbox diag: `{len(origin_failures)}/{n}`; cases: `{', '.join(row['case_id'] for row in origin_failures)}`.", |
| "- Type mistakes switch the revolute/prismatic branch, so they directly zero out strict, relaxed, and axis-only success under the reported definitions and often raise trajectory CD.", |
| "- Origin errors mostly explain the gap between axis-only success and strict success: many cases have a plausible axis but fail the tight origin threshold.", |
| "", |
| "## GPT/VLM Audit Log Status", |
| "", |
| ] |
|
|
| if llm_audit_rows is None: |
| lines += [ |
| "- No `inference_pipeline.py --audit_log` JSONL was supplied.", |
| "- GPT/VLM accuracy is therefore not estimated from missing logs; the report uses the local KPP joint-type head as the measured automatic classifier.", |
| ] |
| else: |
| source_counts = Counter(str(row.get("joint_type_source", "unknown")) for row in llm_audit_rows) |
| llm_enabled = sum(bool(row.get("llm_enabled")) for row in llm_audit_rows) |
| llm_used = sum(str(row.get("joint_type_source")) == "llm" for row in llm_audit_rows) |
| source_summary = ", ".join(f"`{key}`={value}" for key, value in sorted(source_counts.items())) |
| lines += [ |
| f"- Audit rows: `{len(llm_audit_rows)}`", |
| f"- LLM enabled / used as final source: `{fmt_ratio(llm_enabled, len(llm_audit_rows))}` / `{fmt_ratio(llm_used, len(llm_audit_rows))}`", |
| f"- Joint-type source counts: {source_summary}", |
| ] |
|
|
| lines += [ |
| "", |
| "## Segmentation / P3-SAM Status", |
| "", |
| ] |
|
|
| if segmentation_rows is None: |
| lines += [ |
| "- No P3-SAM prediction metrics were supplied or found for this DragMesh run.", |
| "- Therefore the current quantitative GAP-25 result should be described as using provided/ground-truth part labels for the movable mask.", |
| "- The correct reviewer response is to state that P3-SAM is an optional annotation-free front end and to report mask-error propagation qualitatively unless a P3-SAM-vs-GT mask CSV is generated.", |
| ] |
| else: |
| parsed_seg = parse_segmentation_rows(segmentation_rows) |
| seg_by_case = {row["case_id"]: row for row in parsed_seg} |
| ious = [row["iou"] for row in parsed_seg] |
| precisions = [row["precision"] for row in parsed_seg] |
| recalls = [row["recall"] for row in parsed_seg] |
| low_iou_cases = [str(row["case_id"]) for row in parsed_seg if row["iou"] is not None and row["iou"] < 0.25] |
| high_iou_cases = [str(row["case_id"]) for row in parsed_seg if row["iou"] is not None and row["iou"] >= 0.50] |
| iou_summary = summarize(ious) |
| precision_summary = summarize(precisions) |
| recall_summary = summarize(recalls) |
| protocol_bits = [] |
| selection_modes = sorted({str(row["selection_mode"]) for row in parsed_seg if row["selection_mode"]}) |
| prompt_modes = sorted({str(row["prompt_mode"]) for row in parsed_seg if row["prompt_mode"]}) |
| choose_heads = sorted({str(row["choose_head"]) for row in parsed_seg if row["choose_head"]}) |
| if selection_modes: |
| protocol_bits.append("selection=" + "/".join(selection_modes)) |
| if prompt_modes: |
| protocol_bits.append("prompt=" + "/".join(prompt_modes)) |
| if choose_heads: |
| protocol_bits.append("head=" + "/".join(choose_heads)) |
| protocol_text = "; ".join(protocol_bits) if protocol_bits else "mask CSV" |
|
|
| lines += [ |
| f"- Segmentation rows: `{len(segmentation_rows)}`", |
| f"- Protocol tag: `{protocol_text}`", |
| f"- P3-SAM/mask IoU mean / median / max: `{fmt_stat(iou_summary['mean'])}` / `{fmt_stat(iou_summary['median'])}` / `{fmt_stat(iou_summary['max'])}`", |
| f"- Precision mean / median: `{fmt_stat(precision_summary['mean'])}` / `{fmt_stat(precision_summary['median'])}`; recall mean / median: `{fmt_stat(recall_summary['mean'])}` / `{fmt_stat(recall_summary['median'])}`", |
| f"- Low-IoU cases (<0.25): `{len(low_iou_cases)}/{len(segmentation_rows)}`; cases: `{', '.join(low_iou_cases)}`.", |
| f"- Higher-IoU cases (>=0.50): `{len(high_iou_cases)}/{len(segmentation_rows)}`; cases: `{', '.join(high_iou_cases)}`.", |
| "- These mask metrics are not merged into the locked KPP-only kinematic score, because that score was measured with provided masks. If the P3-SAM mask were substituted, low-IoU cases should be counted as upstream segmentation failures before KPP/DQ-VAE execution.", |
| "", |
| "### Mask-Conditioned Risk View", |
| "", |
| "| Mask subset | Count | Type acc under provided-mask KPP | Strict under provided-mask KPP | Mean mask IoU | Mean final CD |", |
| "| --- | ---: | ---: | ---: | ---: | ---: |", |
| ] |
|
|
| joined_rows = [row for row in rows if row["case_id"] in seg_by_case] |
| subsets = [ |
| ("mask IoU < 0.25", [row for row in joined_rows if (seg_by_case[row["case_id"]]["iou"] or 0.0) < 0.25]), |
| ("mask IoU >= 0.25", [row for row in joined_rows if (seg_by_case[row["case_id"]]["iou"] or 0.0) >= 0.25]), |
| ("mask IoU >= 0.50", [row for row in joined_rows if (seg_by_case[row["case_id"]]["iou"] or 0.0) >= 0.50]), |
| ] |
| for name, subset in subsets: |
| denom = len(subset) |
| mask_stats = summarize(seg_by_case[row["case_id"]]["iou"] for row in subset) |
| final_cd = summarize(row["normalized_traj_cd_final"] for row in subset) |
| lines.append( |
| "| " |
| + " | ".join( |
| [ |
| name, |
| str(denom), |
| fmt_ratio(sum(bool(row["type_correct"]) for row in subset), denom), |
| fmt_ratio(sum(bool(row["success_strict"]) for row in subset), denom), |
| fmt_stat(mask_stats["mean"]), |
| fmt_stat(final_cd["mean"]), |
| ] |
| ) |
| + " |" |
| ) |
|
|
| if segmentation_rows is None: |
| p3sam_sentence = ( |
| "The current locked evaluation does not contain P3-SAM predictions; it uses provided part labels, " |
| "so P3-SAM should be described as an optional front end whose mask errors would propagate into KPP point features and Gaussian binding rather than as an evaluated oracle." |
| ) |
| else: |
| parsed_seg = parse_segmentation_rows(segmentation_rows) |
| iou_summary = summarize(row["iou"] for row in parsed_seg) |
| low_iou = sum((row["iou"] or 0.0) < 0.25 for row in parsed_seg) |
| p3sam_sentence = ( |
| "A separate P3-SAM/mask audit on the same GAP-25 cases gives mean/median IoU " |
| f"{fmt_stat(iou_summary['mean'])}/{fmt_stat(iou_summary['median'])}, with {low_iou}/{len(parsed_seg)} cases below 0.25 IoU. " |
| "Because the locked kinematic score uses provided masks, these P3-SAM numbers are reported as upstream-front-end accuracy rather than folded into the KPP-only trajectory score; substituting such masks would corrupt KPP point features and Gaussian binding before motion decoding." |
| ) |
|
|
| lines += [ |
| "", |
| "## Manuscript-Ready Paragraph", |
| "", |
| "For the automatic GAP-25 setting, DragMesh uses the local KPP joint-type head rather than a required GPT/VLM call. The head is correct on " |
| f"{type_correct}/{n} cases. Type errors are not hidden by oracle labels: they switch the revolute/prismatic motion branch and reduce downstream success to " |
| f"{strict}/{n} strict, {relaxed}/{n} relaxed, and {axis_only}/{n} axis-only successes. The failure tail is concentrated in ambiguous sliding-vs-hinge geometries and in origin localization: " |
| f"{len(axis_outliers)}/{n} cases have axis error above 45 degrees, while {len(origin_failures)}/{n} exceed the 0.05 bbox-diagonal origin threshold. " |
| + p3sam_sentence, |
| "", |
| f"Per-case CSV: `{output_csv}`", |
| "", |
| ] |
| return "\n".join(lines) |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument( |
| "--trajectory_csv", |
| type=Path, |
| required=True, |
| help="Locked DragMesh trajectory/kinematic metrics CSV.", |
| ) |
| parser.add_argument( |
| "--segmentation_csv", |
| type=Path, |
| default=None, |
| help="Optional P3-SAM or mask-vs-GT metrics CSV with a case_id column.", |
| ) |
| parser.add_argument( |
| "--llm_audit_jsonl", |
| type=Path, |
| default=None, |
| help="Optional JSONL produced by inference_pipeline.py --audit_log.", |
| ) |
| parser.add_argument( |
| "--output_dir", |
| type=Path, |
| default=Path("results/dependency_error_propagation"), |
| help="Directory for audit outputs.", |
| ) |
| args = parser.parse_args() |
|
|
| raw_rows = read_csv(args.trajectory_csv) |
| rows: List[Dict[str, object]] = [] |
| for row in raw_rows: |
| rows.append( |
| { |
| "case_id": row["case_id"], |
| "category": row["category"], |
| "gt_joint_type": row["gt_joint_type"], |
| "pred_joint_type": row["pred_joint_type"], |
| "type_correct": parse_bool(row["joint_type_correct"]), |
| "axis_error_deg": parse_float(row["axis_error_deg"]), |
| "origin_error_normalized": parse_float(row["origin_error_normalized"]), |
| "success_strict": parse_bool(row["success_strict"]), |
| "success_relaxed": parse_bool(row["success_relaxed"]), |
| "success_axis_only": parse_bool(row["success_axis_only"]), |
| "normalized_traj_cd_mean": parse_float(row["normalized_traj_cd_mean"]), |
| "normalized_traj_cd_final": parse_float(row["normalized_traj_cd_final"]), |
| "endpoint_l2_mean": parse_float(row["endpoint_l2_mean"]), |
| "endpoint_l2_median": parse_float(row["endpoint_l2_median"]), |
| "failure_mode": "", |
| } |
| ) |
|
|
| for row in rows: |
| modes = [] |
| if not row["type_correct"]: |
| modes.append("joint_type_wrong") |
| if (row["axis_error_deg"] or 0.0) >= 45.0: |
| modes.append("axis_outlier_ge45") |
| elif (row["axis_error_deg"] or 0.0) >= 10.0: |
| modes.append("axis_ge10") |
| if (row["origin_error_normalized"] or 0.0) >= 0.10: |
| modes.append("origin_ge010") |
| elif (row["origin_error_normalized"] or 0.0) >= 0.05: |
| modes.append("origin_ge005") |
| row["failure_mode"] = "+".join(modes) if modes else "pass_or_minor" |
|
|
| segmentation_rows = load_optional_segmentation(args.segmentation_csv) |
| llm_audit_rows = load_optional_jsonl(args.llm_audit_jsonl) |
| if segmentation_rows is not None: |
| seg_by_case = {row["case_id"]: row for row in parse_segmentation_rows(segmentation_rows)} |
| for row in rows: |
| seg = seg_by_case.get(row["case_id"]) |
| row["mask_iou"] = None if seg is None else seg["iou"] |
| row["mask_precision"] = None if seg is None else seg["precision"] |
| row["mask_recall"] = None if seg is None else seg["recall"] |
| row["mask_failure_lt_0p25"] = False if seg is None else ((seg["iou"] or 0.0) < 0.25) |
|
|
| args.output_dir.mkdir(parents=True, exist_ok=True) |
| output_csv = args.output_dir / "dependency_error_propagation_cases.csv" |
| fieldnames = [ |
| "case_id", |
| "category", |
| "gt_joint_type", |
| "pred_joint_type", |
| "type_correct", |
| "axis_error_deg", |
| "origin_error_normalized", |
| "success_strict", |
| "success_relaxed", |
| "success_axis_only", |
| "normalized_traj_cd_mean", |
| "normalized_traj_cd_final", |
| "endpoint_l2_mean", |
| "endpoint_l2_median", |
| "failure_mode", |
| ] |
| if segmentation_rows is not None: |
| fieldnames += ["mask_iou", "mask_precision", "mask_recall", "mask_failure_lt_0p25"] |
| write_csv(output_csv, rows, fieldnames) |
|
|
| report = make_markdown_report(rows, segmentation_rows, llm_audit_rows, output_csv) |
| report_path = args.output_dir / "dependency_error_propagation_report.md" |
| report_path.write_text(report) |
|
|
| segmentation_summary = None |
| if segmentation_rows is not None: |
| parsed_seg = parse_segmentation_rows(segmentation_rows) |
| segmentation_summary = { |
| "cases": len(parsed_seg), |
| "iou": summarize(row["iou"] for row in parsed_seg), |
| "precision": summarize(row["precision"] for row in parsed_seg), |
| "recall": summarize(row["recall"] for row in parsed_seg), |
| "low_iou_lt_0p25": sum((row["iou"] or 0.0) < 0.25 for row in parsed_seg), |
| "high_iou_ge_0p50": sum((row["iou"] or 0.0) >= 0.50 for row in parsed_seg), |
| } |
|
|
| summary = { |
| "cases": len(rows), |
| "type_correct": sum(bool(row["type_correct"]) for row in rows), |
| "strict_success": sum(bool(row["success_strict"]) for row in rows), |
| "relaxed_success": sum(bool(row["success_relaxed"]) for row in rows), |
| "axis_only_success": sum(bool(row["success_axis_only"]) for row in rows), |
| "axis_error_deg": summarize(row["axis_error_deg"] for row in rows), |
| "origin_error_normalized": summarize(row["origin_error_normalized"] for row in rows), |
| "normalized_traj_cd_final": summarize(row["normalized_traj_cd_final"] for row in rows), |
| "segmentation_metrics_supplied": segmentation_rows is not None, |
| "segmentation": segmentation_summary, |
| "llm_audit_rows_supplied": llm_audit_rows is not None, |
| } |
| (args.output_dir / "dependency_error_propagation_summary.json").write_text( |
| json.dumps(summary, indent=2, sort_keys=True) |
| ) |
| print(f"Wrote {report_path}") |
| print(f"Wrote {output_csv}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
