claude-turing 3.3.0 → 3.5.0

package/templates/scripts/architecture_surgery.py

@@ -0,0 +1,238 @@
+#!/usr/bin/env python3
+"""Architecture modification for the autoresearch pipeline.
+
+Programmatic architecture changes: add/remove layers, widen/narrow,
+swap activation functions, inject skip connections, change normalization.
+Produces a modified config and instructions for the modified experiment.
+
+Usage:
+    python scripts/architecture_surgery.py exp-042 --op widen 2
+    python scripts/architecture_surgery.py exp-042 --op add-layer
+    python scripts/architecture_surgery.py exp-042 --op swap-activation relu gelu
+    python scripts/architecture_surgery.py --json
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+import yaml
+
+from scripts.turing_io import load_config, load_experiments
+
+DEFAULT_LOG_PATH = "experiments/log.jsonl"
+OPERATIONS = ["add-layer", "remove-layer", "widen", "narrow", "swap-activation",
+              "add-skip", "add-norm", "deepen", "swap-objective"]
+
+
+def plan_operation(
+    operation: str,
+    config: dict,
+    hyperparams: dict,
+    model_type: str,
+    args: list[str] | None = None,
+) -> dict:
+    """Plan an architecture modification.
+
+    Returns a plan dict with new config, parameter count change, and instructions.
+    """
+    args = args or []
+    plan = {
+        "operation": operation,
+        "model_type": model_type,
+        "original_config": hyperparams.copy(),
+        "new_config": hyperparams.copy(),
+        "instructions": [],
+        "param_change": None,
+    }
+
+    is_tree = any(t in model_type.lower() for t in ("xgboost", "lightgbm", "forest", "gbm", "catboost"))
+    is_neural = any(t in model_type.lower() for t in ("mlp", "nn", "pytorch", "tensorflow", "transformer"))
+
+    if operation == "widen":
+        factor = float(args[0]) if args else 2.0
+        if is_neural:
+            hs = hyperparams.get("hidden_size", 256)
+            new_hs = int(hs * factor)
+            plan["new_config"]["hidden_size"] = new_hs
+            plan["instructions"].append(f"Multiply hidden dimensions: {hs} → {new_hs} ({factor}x)")
+            plan["param_change"] = f"+{(factor**2 - 1)*100:.0f}% parameters (quadratic in width)"
+        elif is_tree:
+            n = hyperparams.get("n_estimators", 100)
+            new_n = int(n * factor)
+            plan["new_config"]["n_estimators"] = new_n
+            plan["instructions"].append(f"Increase estimators: {n} → {new_n}")
+            plan["param_change"] = f"+{(factor - 1)*100:.0f}% trees"
+        else:
+            plan["instructions"].append(f"Widen by {factor}x — adjust model-specific width parameters")
+
+    elif operation == "narrow":
+        factor = float(args[0]) if args else 0.5
+        if is_neural:
+            hs = hyperparams.get("hidden_size", 256)
+            new_hs = max(8, int(hs * factor))
+            plan["new_config"]["hidden_size"] = new_hs
+            plan["instructions"].append(f"Reduce hidden dimensions: {hs} → {new_hs} ({factor}x)")
+        elif is_tree:
+            n = hyperparams.get("n_estimators", 100)
+            new_n = max(1, int(n * factor))
+            plan["new_config"]["n_estimators"] = new_n
+            plan["instructions"].append(f"Reduce estimators: {n} → {new_n}")
+
+    elif operation == "add-layer":
+        if is_neural:
+            n_layers = hyperparams.get("n_layers", hyperparams.get("layers", 3))
+            plan["new_config"]["n_layers"] = n_layers + 1
+            plan["instructions"].extend([
+                f"Add layer: {n_layers} → {n_layers + 1}",
+                "New layer initialized with default weights",
+                "Auto warm-start: existing layers loaded from source",
+            ])
+            plan["param_change"] = f"+1 layer ({n_layers} → {n_layers + 1})"
+        else:
+            plan["instructions"].append("add-layer not applicable for non-neural models")
+
+    elif operation == "remove-layer":
+        if is_neural:
+            n_layers = hyperparams.get("n_layers", hyperparams.get("layers", 3))
+            if n_layers > 1:
+                plan["new_config"]["n_layers"] = n_layers - 1
+                plan["instructions"].append(f"Remove layer: {n_layers} → {n_layers - 1}")
+            else:
+                plan["instructions"].append("Cannot remove — only 1 layer remaining")
+        else:
+            plan["instructions"].append("remove-layer not applicable for non-neural models")
+
+    elif operation == "deepen":
+        if is_tree:
+            depth = hyperparams.get("max_depth", 6)
+            new_depth = depth + 2
+            plan["new_config"]["max_depth"] = new_depth
+            plan["instructions"].append(f"Increase max depth: {depth} → {new_depth}")
+        elif is_neural:
+            n_layers = hyperparams.get("n_layers", 3)
+            plan["new_config"]["n_layers"] = n_layers + 2
+            plan["instructions"].append(f"Add 2 layers: {n_layers} → {n_layers + 2}")
+
+    elif operation == "swap-activation":
+        if len(args) >= 2:
+            from_act, to_act = args[0], args[1]
+        else:
+            from_act, to_act = "relu", "gelu"
+        plan["new_config"]["activation"] = to_act
+        plan["instructions"].append(f"Swap activation: {from_act} → {to_act}")
+
+    elif operation == "add-skip":
+        plan["new_config"]["skip_connections"] = True
+        plan["instructions"].append("Inject residual/skip connections between layers")
+
+    elif operation == "add-norm":
+        norm_type = args[0] if args else "batch_norm"
+        plan["new_config"]["normalization"] = norm_type
+        plan["instructions"].append(f"Add {norm_type} after each layer")
+
+    elif operation == "swap-objective":
+        if len(args) >= 2:
+            from_obj, to_obj = args[0], args[1]
+        else:
+            from_obj, to_obj = hyperparams.get("objective", "logloss"), "focal"
+        plan["new_config"]["objective"] = to_obj
+        plan["instructions"].append(f"Swap objective: {from_obj} → {to_obj}")
+
+    else:
+        plan["instructions"].append(f"Unknown operation: {operation}")
+
+    return plan
+
+
+def surgery_report(
+    exp_id: str,
+    operation: str,
+    op_args: list[str] | None = None,
+    config_path: str = "config.yaml",
+    log_path: str = DEFAULT_LOG_PATH,
+) -> dict:
+    """Generate a surgery report."""
+    experiments = load_experiments(log_path)
+    exp = next((e for e in experiments if e.get("experiment_id") == exp_id), None)
+
+    if not exp:
+        return {"error": f"Experiment {exp_id} not found"}
+
+    config = exp.get("config", {})
+    model_type = config.get("model_type", "unknown")
+    hyperparams = config.get("hyperparams", {})
+
+    plan = plan_operation(operation, config, hyperparams, model_type, op_args)
+
+    return {
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "experiment_id": exp_id,
+        "plan": plan,
+        "warm_start_from": exp_id,
+    }
+
+
+def save_surgery_report(report: dict, output_dir: str = "experiments/surgery") -> Path:
+    out = Path(output_dir); out.mkdir(parents=True, exist_ok=True)
+    exp_id = report.get("experiment_id", "unknown")
+    op = report.get("plan", {}).get("operation", "unknown")
+    fp = out / f"{exp_id}-{op}.yaml"
+    with open(fp, "w") as f: yaml.dump(report, f, default_flow_style=False, sort_keys=False)
+    return fp
+
+
+def format_surgery_report(report: dict) -> str:
+    if "error" in report: return f"ERROR: {report['error']}"
+
+    plan = report.get("plan", {})
+    exp_id = report.get("experiment_id", "?")
+    op = plan.get("operation", "?")
+
+    lines = [f"# Surgery: {op} ({exp_id})", "",
+             f"*Generated {report.get('generated_at', 'N/A')[:19]}*",
+             f"**Model:** {plan.get('model_type', '?')}", ""]
+
+    lines.extend(["## Instructions", ""])
+    for i, inst in enumerate(plan.get("instructions", []), 1):
+        lines.append(f"{i}. {inst}")
+    lines.append("")
+
+    if plan.get("param_change"):
+        lines.append(f"**Parameter change:** {plan['param_change']}")
+        lines.append("")
+
+    orig = plan.get("original_config", {})
+    new = plan.get("new_config", {})
+    changed = {k: (orig.get(k), new[k]) for k in new if orig.get(k) != new.get(k)}
+    if changed:
+        lines.extend(["## Config Changes", ""])
+        for k, (old, new_v) in changed.items():
+            lines.append(f"- `{k}`: {old} → {new_v}")
+        lines.append("")
+
+    lines.append(f"**Warm-start from:** {report.get('warm_start_from', '?')}")
+
+    return "\n".join(lines)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Architecture modification")
+    parser.add_argument("exp_id")
+    parser.add_argument("--op", required=True, help="Operation name")
+    parser.add_argument("op_args", nargs="*", help="Operation arguments")
+    parser.add_argument("--config", default="config.yaml")
+    parser.add_argument("--log", default=DEFAULT_LOG_PATH)
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args()
+    report = surgery_report(args.exp_id, args.op, args.op_args, args.config, args.log)
+    if "error" not in report:
+        fp = save_surgery_report(report); print(f"Saved to {fp}", file=sys.stderr)
+    print(json.dumps(report, indent=2, default=str) if args.json else format_surgery_report(report))
+
+if __name__ == "__main__": main()

package/templates/scripts/citation_manager.py

@@ -0,0 +1,436 @@
+#!/usr/bin/env python3
+"""Citation and attribution manager for the autoresearch pipeline.
+
+Tracks academic citations associated with experiments. Every method,
+dataset, technique, and codebase used in the research campaign should
+have a citation. This script manages the citation store, audits for
+missing attributions, and generates BibTeX output.
+
+Usage:
+    python scripts/citation_manager.py add exp-042 --key Chen2016 --title "XGBoost" --url "..."
+    python scripts/citation_manager.py list
+    python scripts/citation_manager.py check
+    python scripts/citation_manager.py bib
+    python scripts/citation_manager.py --json
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+import yaml
+
+from scripts.turing_io import load_config, load_experiments
+
+DEFAULT_LOG_PATH = "experiments/log.jsonl"
+DEFAULT_CITATIONS_PATH = "experiments/citations.yaml"
+VALID_TYPES = ["method", "dataset", "technique", "codebase"]
+
+# Keywords that suggest a method/technique needing citation
+METHOD_KEYWORDS = {
+    "xgboost": "XGBoost (Chen & Guestrin, 2016)",
+    "lightgbm": "LightGBM (Ke et al., 2017)",
+    "catboost": "CatBoost (Prokhorenkova et al., 2018)",
+    "random_forest": "Random Forest (Breiman, 2001)",
+    "gradient_boosting": "Gradient Boosting (Friedman, 2001)",
+    "adam": "Adam optimizer (Kingma & Ba, 2015)",
+    "sgd": "SGD with momentum (Sutskever et al., 2013)",
+    "dropout": "Dropout (Srivastava et al., 2014)",
+    "batch_norm": "Batch Normalization (Ioffe & Szegedy, 2015)",
+    "resnet": "ResNet (He et al., 2016)",
+    "transformer": "Transformer (Vaswani et al., 2017)",
+    "bert": "BERT (Devlin et al., 2019)",
+    "lstm": "LSTM (Hochreiter & Schmidhuber, 1997)",
+    "svm": "SVM (Cortes & Vapnik, 1995)",
+    "lasso": "Lasso (Tibshirani, 1996)",
+    "ridge": "Ridge Regression (Hoerl & Kennard, 1970)",
+    "elastic_net": "Elastic Net (Zou & Hastie, 2005)",
+    "pca": "PCA (Pearson, 1901)",
+    "tsne": "t-SNE (van der Maaten & Hinton, 2008)",
+    "umap": "UMAP (McInnes et al., 2018)",
+    "cross_validation": "Cross-validation (Stone, 1974)",
+    "smote": "SMOTE (Chawla et al., 2002)",
+}
+
+
+# --- Storage ---
+
+
+def load_citations(path: str = DEFAULT_CITATIONS_PATH) -> list[dict]:
+    """Load citations from YAML file."""
+    p = Path(path)
+    if not p.exists() or p.stat().st_size == 0:
+        return []
+    with open(p) as f:
+        data = yaml.safe_load(f)
+    return data if isinstance(data, list) else []
+
+
+def save_citations(citations: list[dict], path: str = DEFAULT_CITATIONS_PATH) -> Path:
+    """Save citations list to YAML."""
+    p = Path(path)
+    p.parent.mkdir(parents=True, exist_ok=True)
+    with open(p, "w") as f:
+        yaml.dump(citations, f, default_flow_style=False, sort_keys=False)
+    return p
+
+
+# --- Operations ---
+
+
+def add_citation(
+    experiment_id: str,
+    key: str,
+    title: str,
+    authors: str | None = None,
+    year: int | None = None,
+    url: str | None = None,
+    doi: str | None = None,
+    cite_type: str = "method",
+    citations_path: str = DEFAULT_CITATIONS_PATH,
+    log_path: str = DEFAULT_LOG_PATH,
+) -> dict:
+    """Add or update a citation, associating it with an experiment.
+
+    If the citation key already exists, the experiment is appended to
+    its experiment list. Otherwise a new citation entry is created.
+    """
+    experiments = load_experiments(log_path)
+    known_ids = {e.get("experiment_id") for e in experiments}
+    if experiment_id not in known_ids:
+        return {"error": f"Experiment '{experiment_id}' not found in log"}
+
+    if cite_type not in VALID_TYPES:
+        return {"error": f"Invalid type '{cite_type}'. Valid: {VALID_TYPES}"}
+
+    citations = load_citations(citations_path)
+
+    # Check if key already exists
+    existing = None
+    for c in citations:
+        if c.get("key") == key:
+            existing = c
+            break
+
+    if existing:
+        if experiment_id not in existing.get("experiments", []):
+            existing.setdefault("experiments", []).append(experiment_id)
+        # Update fields if provided
+        if authors:
+            existing["authors"] = authors
+        if year:
+            existing["year"] = year
+        if url:
+            existing["url"] = url
+        if doi:
+            existing["doi"] = doi
+        save_citations(citations, citations_path)
+        return {"action": "updated", "citation": existing}
+
+    citation = {
+        "key": key,
+        "title": title,
+        "authors": authors or "",
+        "year": year or 0,
+        "url": url or "",
+        "doi": doi or "",
+        "type": cite_type,
+        "experiments": [experiment_id],
+    }
+    citations.append(citation)
+    save_citations(citations, citations_path)
+    return {"action": "added", "citation": citation}
+
+
+def list_citations(
+    citations_path: str = DEFAULT_CITATIONS_PATH,
+) -> dict:
+    """List all citations grouped by type with experiment associations."""
+    citations = load_citations(citations_path)
+    grouped: dict[str, list[dict]] = {}
+    for c in citations:
+        ctype = c.get("type", "unknown")
+        grouped.setdefault(ctype, []).append(c)
+    return {
+        "total": len(citations),
+        "by_type": grouped,
+        "citations": citations,
+    }
+
+
+def check_citations(
+    citations_path: str = DEFAULT_CITATIONS_PATH,
+    log_path: str = DEFAULT_LOG_PATH,
+    config_path: str = "config.yaml",
+) -> dict:
+    """Audit for missing citations — methods used without attribution.
+
+    Scans experiment configs and descriptions for known method keywords
+    that lack a corresponding citation entry.
+    """
+    citations = load_citations(citations_path)
+    experiments = load_experiments(log_path)
+    config = load_config(config_path)
+
+    cited_keys = {c.get("key", "").lower() for c in citations}
+    cited_titles = {c.get("title", "").lower() for c in citations}
+
+    missing: list[dict] = []
+    covered: list[str] = []
+
+    for keyword, suggestion in METHOD_KEYWORDS.items():
+        # Check if this keyword appears in any experiment
+        found_in: list[str] = []
+        for exp in experiments:
+            searchable = json.dumps(exp, default=str).lower()
+            if keyword.lower() in searchable:
+                found_in.append(exp.get("experiment_id", "?"))
+
+        # Also check config
+        config_str = json.dumps(config, default=str).lower()
+        if keyword.lower() in config_str:
+            found_in.append("config.yaml")
+
+        if not found_in:
+            continue
+
+        # Check if cited
+        is_cited = (
+            keyword.lower() in cited_keys
+            or keyword.lower() in cited_titles
+            or any(keyword.lower() in c.get("title", "").lower() for c in citations)
+        )
+
+        if is_cited:
+            covered.append(keyword)
+        else:
+            missing.append({
+                "keyword": keyword,
+                "suggestion": suggestion,
+                "found_in": found_in,
+            })
+
+    return {
+        "missing": missing,
+        "covered": covered,
+        "total_checked": len(METHOD_KEYWORDS),
+        "coverage": f"{len(covered)}/{len(covered) + len(missing)}" if (covered or missing) else "N/A",
+    }
+
+
+def generate_bibtex(citations_path: str = DEFAULT_CITATIONS_PATH) -> str:
+    """Generate BibTeX output from all citations."""
+    citations = load_citations(citations_path)
+    if not citations:
+        return "% No citations found.\n"
+
+    entries = []
+    for c in citations:
+        key = c.get("key", "unknown")
+        title = c.get("title", "")
+        authors = c.get("authors", "")
+        year = c.get("year", 0)
+        url = c.get("url", "")
+        doi = c.get("doi", "")
+
+        # Determine entry type
+        entry_type = "misc"
+        if doi:
+            entry_type = "article"
+
+        lines = [f"@{entry_type}{{{key},"]
+        lines.append(f"  title = {{{title}}},")
+        if authors:
+            lines.append(f"  author = {{{authors}}},")
+        if year:
+            lines.append(f"  year = {{{year}}},")
+        if url:
+            lines.append(f"  url = {{{url}}},")
+        if doi:
+            lines.append(f"  doi = {{{doi}}},")
+        note = f"Type: {c.get('type', 'unknown')}. Used in: {', '.join(c.get('experiments', []))}"
+        lines.append(f"  note = {{{note}}},")
+        lines.append("}")
+        entries.append("\n".join(lines))
+
+    header = f"% Auto-generated by Turing citation manager\n% {len(entries)} citation(s)\n"
+    return header + "\n\n".join(entries) + "\n"
+
+
+# --- Report ---
+
+
+def format_citations_report(result: dict, action: str) -> str:
+    """Format citation results as readable text."""
+    lines: list[str] = []
+
+    if action == "list":
+        total = result.get("total", 0)
+        lines.append(f"# Citations ({total} total)")
+        lines.append("")
+        by_type = result.get("by_type", {})
+        for ctype in VALID_TYPES:
+            cites = by_type.get(ctype, [])
+            if not cites:
+                continue
+            lines.append(f"## {ctype.title()} ({len(cites)})")
+            lines.append("")
+            for c in cites:
+                key = c.get("key", "?")
+                title = c.get("title", "?")
+                authors = c.get("authors", "")
+                year = c.get("year", "")
+                exps = ", ".join(c.get("experiments", []))
+                author_year = f" ({authors}, {year})" if authors and year else ""
+                lines.append(f"- **[{key}]** {title}{author_year}")
+                if exps:
+                    lines.append(f"  Experiments: {exps}")
+            lines.append("")
+
+    elif action == "check":
+        missing = result.get("missing", [])
+        covered = result.get("covered", [])
+        coverage = result.get("coverage", "N/A")
+        lines.append(f"# Citation Audit (coverage: {coverage})")
+        lines.append("")
+        if missing:
+            lines.append(f"## Missing Citations ({len(missing)})")
+            lines.append("")
+            for m in missing:
+                lines.append(f"- **{m['keyword']}**: {m['suggestion']}")
+                lines.append(f"  Found in: {', '.join(m['found_in'])}")
+            lines.append("")
+        if covered:
+            lines.append(f"## Covered ({len(covered)})")
+            lines.append("")
+            for kw in covered:
+                lines.append(f"- {kw}")
+            lines.append("")
+        if not missing:
+            lines.append("All detected methods have citations.")
+
+    elif action == "add":
+        cite = result.get("citation", {})
+        act = result.get("action", "added")
+        lines.append(f"Citation {act}: [{cite.get('key')}] {cite.get('title')}")
+        lines.append(f"  Type: {cite.get('type')} | Experiments: {', '.join(cite.get('experiments', []))}")
+
+    return "\n".join(lines)
+
+
+def save_citations_report(report: dict, path: str = "experiments/citations") -> Path:
+    """Save citation report to YAML."""
+    p = Path(path)
+    p.mkdir(parents=True, exist_ok=True)
+    out = p / f"report-{datetime.now(timezone.utc).strftime('%Y%m%d-%H%M%S')}.yaml"
+    with open(out, "w") as f:
+        yaml.dump(report, f, default_flow_style=False, sort_keys=False)
+    return out
+
+
+# --- Orchestration ---
+
+
+def run_citation_manager(
+    action: str,
+    experiment_id: str | None = None,
+    key: str | None = None,
+    title: str | None = None,
+    authors: str | None = None,
+    year: int | None = None,
+    url: str | None = None,
+    doi: str | None = None,
+    cite_type: str = "method",
+    citations_path: str = DEFAULT_CITATIONS_PATH,
+    log_path: str = DEFAULT_LOG_PATH,
+    config_path: str = "config.yaml",
+) -> dict:
+    """Run citation manager operation."""
+    timestamp = datetime.now(timezone.utc).isoformat()
+
+    if action == "add":
+        if not experiment_id or not key or not title:
+            return {"error": "add requires experiment_id, --key, and --title"}
+        result = add_citation(
+            experiment_id, key, title, authors, year, url, doi,
+            cite_type, citations_path, log_path,
+        )
+        if "error" in result:
+            return {"timestamp": timestamp, **result}
+        return {"timestamp": timestamp, "action": "add", **result}
+
+    elif action == "list":
+        result = list_citations(citations_path)
+        return {"timestamp": timestamp, "action": "list", **result}
+
+    elif action == "check":
+        result = check_citations(citations_path, log_path, config_path)
+        return {"timestamp": timestamp, "action": "check", **result}
+
+    elif action == "bib":
+        bibtex = generate_bibtex(citations_path)
+        return {"timestamp": timestamp, "action": "bib", "bibtex": bibtex,
+                "count": len(load_citations(citations_path))}
+
+    return {"error": f"Unknown action: {action}"}
+
+
+def main() -> None:
+    """CLI entry point."""
+    parser = argparse.ArgumentParser(
+        description="Citation and attribution manager for ML experiments",
+    )
+    parser.add_argument("action", choices=["add", "list", "check", "bib"],
+                        help="Citation action")
+    parser.add_argument("experiment_id", nargs="?", default=None,
+                        help="Experiment ID (for add)")
+    parser.add_argument("--key", default=None, help="Citation key (e.g., Chen2016)")
+    parser.add_argument("--title", default=None, help="Paper/resource title")
+    parser.add_argument("--authors", default=None, help="Author list")
+    parser.add_argument("--year", type=int, default=None, help="Publication year")
+    parser.add_argument("--url", default=None, help="URL to paper/resource")
+    parser.add_argument("--doi", default=None, help="DOI identifier")
+    parser.add_argument("--type", dest="cite_type", default="method",
+                        choices=VALID_TYPES, help="Citation type")
+    parser.add_argument("--config", default="config.yaml", help="Path to config.yaml")
+    parser.add_argument("--log", default=DEFAULT_LOG_PATH, help="Path to experiment log")
+    parser.add_argument("--citations-path", default=DEFAULT_CITATIONS_PATH,
+                        help="Path to citations YAML")
+    parser.add_argument("--json", action="store_true", help="Output raw JSON")
+    args = parser.parse_args()
+
+    report = run_citation_manager(
+        action=args.action,
+        experiment_id=args.experiment_id,
+        key=args.key,
+        title=args.title,
+        authors=args.authors,
+        year=args.year,
+        url=args.url,
+        doi=args.doi,
+        cite_type=args.cite_type,
+        citations_path=args.citations_path,
+        log_path=args.log,
+        config_path=args.config,
+    )
+
+    if args.json:
+        print(json.dumps(report, indent=2, default=str))
+    else:
+        if "error" in report:
+            print(f"ERROR: {report['error']}", file=sys.stderr)
+            sys.exit(1)
+        action = report.get("action", "")
+        if action == "bib":
+            print(report["bibtex"])
+        else:
+            print(format_citations_report(report, action))
+
+
+if __name__ == "__main__":
+    main()