#!/usr/bin/env python3 from __future__ import annotations import argparse import json from pathlib import Path from typing import Any import numpy as np import pandas as pd from sklearn.metrics import pairwise_distances from sklearn.preprocessing import StandardScaler def parse_args() -> argparse.Namespace: parser = argparse.ArgumentParser( description="Run the CB-Telemetry time-matched retrieval protocol on released feature tables." ) parser.add_argument("--root", default=".", help="CB-Telemetry dataset root.") parser.add_argument("--feature-table", required=True, help="Anchor feature table used to define rows and slots.") parser.add_argument("--output-dir", required=True, help="Directory for retrieval outputs.") parser.add_argument("--max-slot-gap", type=int, default=1, help="Maximum neighboring-slot gap.") parser.add_argument("--min-dates-per-pair", type=int, default=12, help="Minimum dates required per slot pair.") parser.add_argument("--bootstrap-samples", type=int, default=2000, help="Bootstrap resamples for intervals.") parser.add_argument("--bootstrap-seed", type=int, default=42, help="Bootstrap random seed.") parser.add_argument("--random-seed", type=int, default=42, help="Random seed for the permuted-control baseline.") parser.add_argument( "--archive-scope", choices=["global", "same_archive_only"], default="global", help="Candidate pool: all target rows, or rows from the same archive only.", ) parser.add_argument( "--representation", action="append", default=[], help="Repeat as name=feature_table_path. Paths are resolved relative to --root unless absolute.", ) parser.add_argument( "--include-metadata-controls", action="store_true", help="Add metadata_basic, metadata_calendar, and random_permuted_continuous controls.", ) return parser.parse_args() def resolve_path(root: Path, raw_path: str) -> Path: path = Path(raw_path).expanduser() if not path.is_absolute(): path = (root / path).resolve() return path def release_path(root: Path, path: Path) -> str: try: return path.resolve().relative_to(root).as_posix() except ValueError: return path.as_posix() def build_key(df: pd.DataFrame) -> pd.Series: return ( df["archive"].astype(str).str.strip() + "||" + df["date"].astype(str).str.strip() + "||" + df["filename"].astype(str).str.strip() ) def add_slot_metadata(df: pd.DataFrame) -> pd.DataFrame: result = df.copy() result["timestamp_dt"] = pd.to_datetime(result["timestamp"], errors="raise") result["date"] = result["date"].astype(str) result["archive"] = result["archive"].astype(str) result["filename"] = result["filename"].astype(str) result["key"] = build_key(result) result["dawn_slot_id"] = 0 result["slot_count_on_date"] = 0 result["slot_hour_signature"] = "" for date_str, group in result.groupby("date", sort=True): ordered = group.sort_values(["timestamp_dt", "filename"]).copy() slot_ids = np.arange(1, len(ordered) + 1, dtype=np.int32) result.loc[ordered.index, "dawn_slot_id"] = slot_ids result.loc[ordered.index, "slot_count_on_date"] = int(len(ordered)) signature = "-".join(str(int(item)) for item in ordered["hour"].tolist()) result.loc[ordered.index, "slot_hour_signature"] = signature result["dawn_slot_id"] = result["dawn_slot_id"].astype(int) result["slot_count_on_date"] = result["slot_count_on_date"].astype(int) return result def feature_columns(df: pd.DataFrame) -> list[str]: columns = [col for col in df.columns if col.startswith("f_")] if not columns: raise RuntimeError("No f_* feature columns were found.") return columns def standardize(matrix: np.ndarray) -> np.ndarray: return StandardScaler().fit_transform(matrix.astype(np.float32, copy=False)).astype(np.float32) def load_representation_matrix(root: Path, path_text: str, anchor_df: pd.DataFrame) -> np.ndarray: path = resolve_path(root, path_text) df = pd.read_csv(path, low_memory=False).copy() df["date"] = df["date"].astype(str) df["archive"] = df["archive"].astype(str) df["filename"] = df["filename"].astype(str) df["key"] = build_key(df) columns = feature_columns(df) indexed = df.set_index("key") keys = anchor_df["key"].tolist() missing = [key for key in keys if key not in indexed.index] if missing: raise RuntimeError(f"{path} is missing {len(missing)} anchor rows.") matrix = indexed.loc[keys, columns].to_numpy(dtype=np.float32) return standardize(matrix) def parse_representations(items: list[str]) -> list[tuple[str, str]]: if not items: raise ValueError("At least one --representation name=path is required.") result: list[tuple[str, str]] = [] for item in items: if "=" not in item: raise ValueError(f"Invalid representation argument: {item}") name, raw_path = item.split("=", 1) result.append((name.strip(), raw_path.strip())) return result def build_metadata_matrix(anchor_df: pd.DataFrame, include_calendar: bool) -> np.ndarray: archive_dummies = pd.get_dummies(anchor_df["archive"].astype(str), prefix="archive", dtype=np.float32) slot_dummies = pd.get_dummies(anchor_df["dawn_slot_id"].astype(int), prefix="slot", dtype=np.float32) blocks = [ anchor_df["hour"].astype(np.float32).to_numpy()[:, None], archive_dummies.to_numpy(dtype=np.float32), slot_dummies.to_numpy(dtype=np.float32), ] if include_calendar: date_dt = pd.to_datetime(anchor_df["date"].astype(str), format="%Y%m%d", errors="raise") month_angle = 2.0 * np.pi * (date_dt.dt.month.to_numpy(dtype=np.float32) - 1.0) / 12.0 year_offset = date_dt.dt.year.to_numpy(dtype=np.float32) - float(date_dt.dt.year.min()) blocks.extend( [ np.sin(month_angle).astype(np.float32)[:, None], np.cos(month_angle).astype(np.float32)[:, None], year_offset.astype(np.float32)[:, None], ] ) return standardize(np.column_stack(blocks).astype(np.float32)) def cosine_rank_indices(query_matrix: np.ndarray, target_matrix: np.ndarray) -> np.ndarray: distances = pairwise_distances(query_matrix, target_matrix, metric="cosine") return np.argsort(distances, axis=1) def reciprocal_rank(rank_index_zero_based: int) -> float: return 1.0 / float(rank_index_zero_based + 1) def summarize_query_rows(query_df: pd.DataFrame) -> dict[str, float]: rank_positions = query_df["rank_position"].to_numpy(dtype=np.float32) return { "top1_hit_rate": float(query_df["top1_hit"].mean()), "top5_hit_rate": float(query_df["top5_hit"].mean()), "mrr": float(query_df["reciprocal_rank"].mean()), "median_rank": float(np.median(rank_positions)), "mean_rank": float(np.mean(rank_positions)), } def evaluate_pair_subset( matrix: np.ndarray, pair_df: pd.DataFrame, query_slot: int, target_slot: int, archive_label: str, ) -> dict[str, Any]: eligible_dates = pair_df.groupby("date")["dawn_slot_id"].nunique().reset_index(name="slot_count") eligible_dates = eligible_dates[eligible_dates["slot_count"] == 2]["date"].astype(str).tolist() pair_df = pair_df[pair_df["date"].isin(eligible_dates)].copy() query_df = pair_df[pair_df["dawn_slot_id"] == query_slot].copy().sort_values("date").reset_index(drop=True) target_df = pair_df[pair_df["dawn_slot_id"] == target_slot].copy().sort_values("date").reset_index(drop=True) if query_df.empty or target_df.empty: raise RuntimeError(f"slot_pair {query_slot}->{target_slot} has no valid rows.") if query_df["date"].tolist() != target_df["date"].tolist(): raise RuntimeError(f"slot_pair {query_slot}->{target_slot} query and target dates are not aligned.") query_matrix = matrix[query_df["anchor_row_index"].to_numpy()] target_matrix = matrix[target_df["anchor_row_index"].to_numpy()] ranks = cosine_rank_indices(query_matrix, target_matrix) positive_dates = query_df["date"].tolist() target_dates = target_df["date"].tolist() query_rows: list[dict[str, Any]] = [] for row_idx, expected_date in enumerate(positive_dates): ranked_dates = [target_dates[item] for item in ranks[row_idx].tolist()] positive_rank = ranked_dates.index(expected_date) query_rows.append( { "date": str(expected_date), "query_slot": int(query_slot), "target_slot": int(target_slot), "archive_scope_label": archive_label, "candidate_size_per_query": int(len(target_df)), "chance_top1": 1.0 / float(len(target_df)), "rank_position": int(positive_rank + 1), "top1_hit": 1.0 if positive_rank == 0 else 0.0, "top5_hit": 1.0 if positive_rank < min(5, len(ranked_dates)) else 0.0, "reciprocal_rank": reciprocal_rank(positive_rank), } ) query_result_df = pd.DataFrame(query_rows) metrics = summarize_query_rows(query_result_df) return { "query_slot": int(query_slot), "target_slot": int(target_slot), "archive_scope_label": archive_label, "query_rows": int(len(query_df)), "candidate_rows": int(len(target_df)), "candidate_size_per_query": int(len(target_df)), "chance_top1": 1.0 / float(len(target_df)), "top1_hit_rate": metrics["top1_hit_rate"], "top5_hit_rate": metrics["top5_hit_rate"], "mrr": metrics["mrr"], "median_rank": metrics["median_rank"], "mean_rank": metrics["mean_rank"], "date_examples": positive_dates[:5], "query_details": query_rows, } def evaluate_slot_pair( matrix: np.ndarray, anchor_df: pd.DataFrame, query_slot: int, target_slot: int, archive_scope: str, min_dates_per_pair: int, ) -> list[dict[str, Any]]: pair_df = anchor_df[anchor_df["dawn_slot_id"].isin([query_slot, target_slot])].copy() if archive_scope == "global": return [ evaluate_pair_subset( matrix, pair_df=pair_df, query_slot=query_slot, target_slot=target_slot, archive_label="all", ) ] rows: list[dict[str, Any]] = [] for archive_name, archive_df in pair_df.groupby("archive", sort=True): if archive_df["dawn_slot_id"].nunique() < 2: continue eligible_dates = archive_df.groupby("date")["dawn_slot_id"].nunique().reset_index(name="slot_count") eligible_dates = eligible_dates[eligible_dates["slot_count"] == 2] if int(len(eligible_dates)) < min_dates_per_pair: continue rows.append( evaluate_pair_subset( matrix, pair_df=archive_df.copy(), query_slot=query_slot, target_slot=target_slot, archive_label=str(archive_name), ) ) return rows def build_slot_pairs( anchor_df: pd.DataFrame, max_slot_gap: int, min_dates_per_pair: int, archive_scope: str, ) -> list[tuple[int, int]]: max_slot_id = int(anchor_df["dawn_slot_id"].max()) pairs: list[tuple[int, int]] = [] for query_slot in range(1, max_slot_id + 1): for target_slot in range(1, max_slot_id + 1): if query_slot == target_slot: continue if abs(query_slot - target_slot) > max_slot_gap: continue pair_df = anchor_df[anchor_df["dawn_slot_id"].isin([query_slot, target_slot])].copy() if archive_scope == "global": eligible_dates = pair_df.groupby("date")["dawn_slot_id"].nunique().reset_index(name="slot_count") eligible_dates = eligible_dates[eligible_dates["slot_count"] == 2] if int(len(eligible_dates)) >= min_dates_per_pair: pairs.append((query_slot, target_slot)) continue archive_has_valid_pair = False for _, archive_df in pair_df.groupby("archive", sort=True): if archive_df["dawn_slot_id"].nunique() < 2: continue eligible_dates = archive_df.groupby("date")["dawn_slot_id"].nunique().reset_index(name="slot_count") eligible_dates = eligible_dates[eligible_dates["slot_count"] == 2] if int(len(eligible_dates)) >= min_dates_per_pair: archive_has_valid_pair = True break if archive_has_valid_pair: pairs.append((query_slot, target_slot)) if not pairs: raise RuntimeError("No valid slot pairs satisfy min_dates_per_pair.") return sorted(pairs) def aggregate_pair_rows(method_name: str, pair_df: pd.DataFrame) -> dict[str, float | str]: return { "method": method_name, "mean_top1_hit_rate": float(pair_df["top1_hit_rate"].mean()), "mean_top5_hit_rate": float(pair_df["top5_hit_rate"].mean()), "mean_mrr": float(pair_df["mrr"].mean()), "mean_median_rank": float(pair_df["median_rank"].mean()), "mean_candidate_size": float(pair_df["candidate_size_per_query"].mean()), "mean_chance_top1": float(pair_df["chance_top1"].mean()), } def evaluate_representation( method_name: str, matrix: np.ndarray, anchor_df: pd.DataFrame, slot_pairs: list[tuple[int, int]], archive_scope: str, min_dates_per_pair: int, ) -> dict[str, Any]: pair_rows: list[dict[str, Any]] = [] query_rows: list[dict[str, Any]] = [] for query_slot, target_slot in slot_pairs: rows = evaluate_slot_pair( matrix, anchor_df, query_slot=query_slot, target_slot=target_slot, archive_scope=archive_scope, min_dates_per_pair=min_dates_per_pair, ) for row in rows: raw_query_details = row.pop("query_details") row["method"] = method_name pair_rows.append(row) for query_detail in raw_query_details: query_detail["method"] = method_name query_rows.append(query_detail) if not pair_rows: raise RuntimeError(f"method={method_name} has no valid pair rows.") aggregate = aggregate_pair_rows(method_name, pd.DataFrame(pair_rows)) return {"aggregate": aggregate, "pairs": pair_rows, "queries": query_rows} def percentile_interval(samples: list[float]) -> tuple[float, float]: values = np.asarray(samples, dtype=np.float64) return float(np.percentile(values, 2.5)), float(np.percentile(values, 97.5)) def bootstrap_pair_level( method_name: str, pair_df: pd.DataFrame, bootstrap_samples: int, rng: np.random.Generator, ) -> dict[str, Any]: metric_names = ["top1_hit_rate", "mrr", "top5_hit_rate"] point_estimates = {metric: float(pair_df[metric].mean()) for metric in metric_names} boot_values = {metric: [] for metric in metric_names} pair_count = len(pair_df) for _ in range(bootstrap_samples): sampled_indices = rng.integers(0, pair_count, size=pair_count) sampled = pair_df.iloc[sampled_indices] for metric in metric_names: boot_values[metric].append(float(sampled[metric].mean())) result: dict[str, Any] = { "method": method_name, "bootstrap_unit": "pair", "bootstrap_samples": int(bootstrap_samples), "group_count": int(pair_count), } for metric in metric_names: ci_low, ci_high = percentile_interval(boot_values[metric]) result[f"{metric}_point_estimate"] = point_estimates[metric] result[f"{metric}_ci_low"] = ci_low result[f"{metric}_ci_high"] = ci_high return result def bootstrap_date_level( method_name: str, query_df: pd.DataFrame, bootstrap_samples: int, rng: np.random.Generator, ) -> dict[str, Any]: grouped_queries = { group_key: group.copy().reset_index(drop=True) for group_key, group in query_df.groupby(["query_slot", "target_slot", "archive_scope_label"], sort=True) } point_pair_rows: list[dict[str, float | str]] = [] for group_key, group in grouped_queries.items(): metrics = summarize_query_rows(group) point_pair_rows.append( { "group_key": str(group_key), "top1_hit_rate": metrics["top1_hit_rate"], "mrr": metrics["mrr"], "top5_hit_rate": metrics["top5_hit_rate"], } ) point_pair_df = pd.DataFrame(point_pair_rows) point_estimates = { "top1_hit_rate": float(point_pair_df["top1_hit_rate"].mean()), "mrr": float(point_pair_df["mrr"].mean()), "top5_hit_rate": float(point_pair_df["top5_hit_rate"].mean()), } boot_values = {"top1_hit_rate": [], "mrr": [], "top5_hit_rate": []} for _ in range(bootstrap_samples): sampled_pair_rows: list[dict[str, float | str]] = [] for group_key, group in grouped_queries.items(): sampled_indices = rng.integers(0, len(group), size=len(group)) sampled_group = group.iloc[sampled_indices].reset_index(drop=True) metrics = summarize_query_rows(sampled_group) sampled_pair_rows.append( { "group_key": str(group_key), "top1_hit_rate": metrics["top1_hit_rate"], "mrr": metrics["mrr"], "top5_hit_rate": metrics["top5_hit_rate"], } ) sampled_pair_df = pd.DataFrame(sampled_pair_rows) boot_values["top1_hit_rate"].append(float(sampled_pair_df["top1_hit_rate"].mean())) boot_values["mrr"].append(float(sampled_pair_df["mrr"].mean())) boot_values["top5_hit_rate"].append(float(sampled_pair_df["top5_hit_rate"].mean())) result: dict[str, Any] = { "method": method_name, "bootstrap_unit": "date", "bootstrap_samples": int(bootstrap_samples), "group_count": int(len(grouped_queries)), "query_row_count": int(len(query_df)), } for metric in ["top1_hit_rate", "mrr", "top5_hit_rate"]: ci_low, ci_high = percentile_interval(boot_values[metric]) result[f"{metric}_point_estimate"] = point_estimates[metric] result[f"{metric}_ci_low"] = ci_low result[f"{metric}_ci_high"] = ci_high return result def bootstrap_rows( method_name: str, pair_df: pd.DataFrame, query_df: pd.DataFrame, bootstrap_samples: int, bootstrap_seed: int, ) -> list[dict[str, Any]]: pair_rng = np.random.default_rng(bootstrap_seed) date_rng = np.random.default_rng(bootstrap_seed + 1000) return [ bootstrap_date_level(method_name, query_df, bootstrap_samples=bootstrap_samples, rng=date_rng), bootstrap_pair_level(method_name, pair_df, bootstrap_samples=bootstrap_samples, rng=pair_rng), ] def write_markdown(output_path: Path, summary: dict[str, Any]) -> None: lines = [ "# CB-Telemetry Time-Matched Retrieval", "", f"- feature_table: `{summary['feature_table']}`", f"- max_slot_gap: `{summary['max_slot_gap']}`", f"- min_dates_per_pair: `{summary['min_dates_per_pair']}`", f"- archive_scope: `{summary['archive_scope']}`", f"- bootstrap_samples: `{summary['bootstrap_samples']}`", f"- slot_pairs: `{summary['slot_pairs']}`", "", "## Aggregate", "", "| method | top1 | chance_top1 | mrr | top5 | mean_candidate_size |", "| --- | --- | --- | --- | --- | --- |", ] for row in summary["aggregate_rows"]: lines.append( f"| {row['method']} | {row['mean_top1_hit_rate']:.4f} | {row['mean_chance_top1']:.4f} | " f"{row['mean_mrr']:.4f} | {row['mean_top5_hit_rate']:.4f} | {row['mean_candidate_size']:.1f} |" ) lines.extend(["", "## Bootstrap 95% CI", "", "| method | unit | top1 | mrr | top5 |", "| --- | --- | --- | --- | --- |"]) for row in summary["bootstrap_rows"]: lines.append( f"| {row['method']} | {row['bootstrap_unit']} | " f"{row['top1_hit_rate_point_estimate']:.4f} [{row['top1_hit_rate_ci_low']:.4f}, {row['top1_hit_rate_ci_high']:.4f}] | " f"{row['mrr_point_estimate']:.4f} [{row['mrr_ci_low']:.4f}, {row['mrr_ci_high']:.4f}] | " f"{row['top5_hit_rate_point_estimate']:.4f} [{row['top5_hit_rate_ci_low']:.4f}, {row['top5_hit_rate_ci_high']:.4f}] |" ) output_path.write_text("\n".join(lines) + "\n", encoding="utf-8") def main() -> None: args = parse_args() root = Path(args.root).expanduser().resolve() output_dir = resolve_path(root, args.output_dir) output_dir.mkdir(parents=True, exist_ok=True) feature_table_path = resolve_path(root, args.feature_table) anchor_df = add_slot_metadata(pd.read_csv(feature_table_path, low_memory=False)) anchor_df = anchor_df.sort_values(["date", "timestamp_dt", "filename"]).reset_index(drop=True) anchor_df["anchor_row_index"] = np.arange(len(anchor_df), dtype=np.int32) slot_pairs = build_slot_pairs( anchor_df, max_slot_gap=args.max_slot_gap, min_dates_per_pair=args.min_dates_per_pair, archive_scope=args.archive_scope, ) representation_matrices: list[tuple[str, np.ndarray, str]] = [] for method_name, raw_path in parse_representations(args.representation): representation_matrices.append((method_name, load_representation_matrix(root, raw_path, anchor_df), raw_path)) if args.include_metadata_controls: representation_matrices.append(("metadata_basic", build_metadata_matrix(anchor_df, include_calendar=False), "generated")) representation_matrices.append(("metadata_calendar", build_metadata_matrix(anchor_df, include_calendar=True), "generated")) continuous_columns = feature_columns(anchor_df) continuous_matrix = anchor_df[continuous_columns].to_numpy(dtype=np.float32) rng = np.random.default_rng(args.random_seed) permuted = continuous_matrix[rng.permutation(len(anchor_df))] representation_matrices.append(("random_permuted_continuous", standardize(permuted), "generated")) aggregate_rows: list[dict[str, Any]] = [] pair_rows: list[dict[str, Any]] = [] query_rows: list[dict[str, Any]] = [] all_bootstrap_rows: list[dict[str, Any]] = [] detailed_results: dict[str, Any] = {} for method_name, matrix, source_path in representation_matrices: result = evaluate_representation( method_name=method_name, matrix=matrix, anchor_df=anchor_df, slot_pairs=slot_pairs, archive_scope=args.archive_scope, min_dates_per_pair=args.min_dates_per_pair, ) aggregate_rows.append(result["aggregate"]) pair_rows.extend(result["pairs"]) query_rows.extend(result["queries"]) method_pair_df = pd.DataFrame(result["pairs"]) method_query_df = pd.DataFrame(result["queries"]) method_bootstrap_rows = bootstrap_rows( method_name=method_name, pair_df=method_pair_df, query_df=method_query_df, bootstrap_samples=args.bootstrap_samples, bootstrap_seed=args.bootstrap_seed, ) all_bootstrap_rows.extend(method_bootstrap_rows) detailed_results[method_name] = { "feature_table": source_path, "aggregate": result["aggregate"], "bootstrap": method_bootstrap_rows, } aggregate_df = pd.DataFrame(aggregate_rows).sort_values( ["mean_top1_hit_rate", "mean_mrr", "mean_top5_hit_rate"], ascending=False, ).reset_index(drop=True) pair_df = pd.DataFrame(pair_rows).sort_values(["method", "query_slot", "target_slot"]).reset_index(drop=True) query_df = pd.DataFrame(query_rows).sort_values( ["method", "query_slot", "target_slot", "archive_scope_label", "date"] ).reset_index(drop=True) bootstrap_df = pd.DataFrame(all_bootstrap_rows).sort_values( ["bootstrap_unit", "top1_hit_rate_point_estimate", "mrr_point_estimate", "top5_hit_rate_point_estimate"], ascending=[True, False, False, False], ).reset_index(drop=True) aggregate_df.to_csv(output_dir / "aggregate_summary.csv", index=False) pair_df.to_csv(output_dir / "pair_summary.csv", index=False) query_df.to_csv(output_dir / "query_summary.csv", index=False) bootstrap_df.to_csv(output_dir / "bootstrap_summary.csv", index=False) summary: dict[str, Any] = { "feature_table": release_path(root, feature_table_path), "output_dir": release_path(root, output_dir), "files": { "aggregate_summary_csv": release_path(root, output_dir / "aggregate_summary.csv"), "pair_summary_csv": release_path(root, output_dir / "pair_summary.csv"), "query_summary_csv": release_path(root, output_dir / "query_summary.csv"), "bootstrap_summary_csv": release_path(root, output_dir / "bootstrap_summary.csv"), }, "max_slot_gap": int(args.max_slot_gap), "min_dates_per_pair": int(args.min_dates_per_pair), "archive_scope": args.archive_scope, "bootstrap_samples": int(args.bootstrap_samples), "bootstrap_seed": int(args.bootstrap_seed), "slot_pairs": [f"{src}->{dst}" for src, dst in slot_pairs], "rows": int(len(anchor_df)), "date_count": int(anchor_df["date"].nunique()), "slot_count_distribution": { str(key): int(value) for key, value in anchor_df.groupby("date")["dawn_slot_id"].max().value_counts().sort_index().to_dict().items() }, "aggregate_rows": aggregate_df.to_dict(orient="records"), "bootstrap_rows": bootstrap_df.to_dict(orient="records"), "pair_rows": pair_df.to_dict(orient="records"), "detailed_results": detailed_results, } (output_dir / "summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8") write_markdown(output_dir / "summary.md", summary) print( json.dumps( { "output_dir": summary["output_dir"], "archive_scope": summary["archive_scope"], "max_slot_gap": summary["max_slot_gap"], "aggregate_rows": summary["aggregate_rows"], }, ensure_ascii=False, indent=2, ) ) if __name__ == "__main__": main()