convexpi-lab 0.1.0__tar.gz

convexpi_lab-0.1.0/.github/workflows/anomalies.yml

@@ -0,0 +1,49 @@
+name: Refresh anomaly stats
+
+on:
+  schedule:
+    - cron: "0 4 1 * *"   # 1st of each month at 04:00 UTC
+  workflow_dispatch:
+
+jobs:
+  refresh:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          repository: convexpi/platform
+          token: ${{ secrets.PLATFORM_REPO_TOKEN }}
+          path: platform
+
+      - uses: actions/checkout@v4
+        with:
+          path: lab
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: pip
+
+      - name: Install convexpi-lab
+        working-directory: lab
+        run: pip install -e ".[dev]" --quiet
+
+      - name: Compute anomaly stats
+        working-directory: lab
+        run: python deploy/compute_anomaly_stats.py --output ../platform/web/public/anomaly-stats.json
+
+      - name: Commit to platform repo if changed
+        working-directory: platform
+        run: |
+          git config user.name  "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add web/public/anomaly-stats.json
+          if git diff --cached --quiet; then
+            echo "No changes to anomaly stats"
+          else
+            git commit -m "chore: refresh anomaly stats $(date -u +%Y-%m)"
+            git push
+          fi

convexpi_lab-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,30 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    name: Python ${{ matrix.python-version }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.11", "3.12"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: pip
+
+      - name: Install package and dev dependencies
+        run: pip install -e ".[dev]"
+
+      - name: Run tests
+        run: pytest --tb=short -q

convexpi_lab-0.1.0/.github/workflows/forward.yml

@@ -0,0 +1,31 @@
+name: Forward paper-trading
+
+on:
+  schedule:
+    - cron: '0 6 * * *'   # 06:00 UTC daily
+  workflow_dispatch:
+
+jobs:
+  forward-run:
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Install convexpi-lab
+        run: pip install -e ".[deploy]"
+
+      - name: Run forward evaluator
+        env:
+          SUPABASE_URL:         ${{ secrets.SUPABASE_URL }}
+          SUPABASE_SERVICE_KEY: ${{ secrets.SUPABASE_SERVICE_KEY }}
+          MARKET_SEED_BASE:     ${{ secrets.MARKET_SEED_BASE }}
+          DISCORD_WEBHOOK_URL:  ${{ secrets.DISCORD_WEBHOOK_URL }}
+          FORWARD_WINDOW_DAYS:  "60"
+          FORWARD_N_STOCKS:     "100"
+        run: python deploy/forward_runner.py

convexpi_lab-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,29 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  build-and-publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Install build tools
+        run: pip install hatch
+
+      - name: Build package
+        run: hatch build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

convexpi_lab-0.1.0/.gitignore

@@ -0,0 +1,13 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.venv/
+venv/
+.env
+*.csv
+.DS_Store
+*.so
+*.dylib
+~/.convexpi/   # cached data downloads

convexpi_lab-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shane Conway
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

convexpi_lab-0.1.0/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: convexpi-lab
+Version: 0.1.0
+Summary: ConvexPi Lab — synthetic equity panel, backtester, and anti-overfitting grader
+Project-URL: Homepage, https://convexpi.ai
+Project-URL: Repository, https://github.com/convexpi/lab
+Project-URL: Documentation, https://convexpi.ai/docs
+Project-URL: Bug Tracker, https://github.com/convexpi/lab/issues
+License: MIT
+License-File: LICENSE
+Keywords: alpha,backtesting,education,factor-model,finance,quant
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business :: Financial
+Requires-Python: >=3.10
+Requires-Dist: numpy>=1.24
+Requires-Dist: pandas>=2.0
+Requires-Dist: scipy>=1.10
+Provides-Extra: deploy
+Requires-Dist: sentry-sdk>=2.0; extra == 'deploy'
+Requires-Dist: supabase>=2.0; extra == 'deploy'
+Provides-Extra: dev
+Requires-Dist: hatch; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Provides-Extra: real-data
+Requires-Dist: pandas-datareader>=0.10; extra == 'real-data'
+Requires-Dist: yfinance>=0.2; extra == 'real-data'
+Description-Content-Type: text/markdown
+
+# convexpi-lab
+
+Synthetic equity panel generator, walk-forward backtester, and anti-overfitting grader for quantitative finance education and research.
+
+```bash
+pip install convexpi-lab
+```
+
+Part of the [ConvexPi](https://convexpi.ai) platform. See also [convexpi-arena](https://github.com/convexpi/arena) for the live exchange simulator.
+
+## Quick start
+
+```python
+from convexpi.lab import SyntheticMarket, Backtest, LongShortRank
+
+market = SyntheticMarket(n_stocks=50, n_days=756, seed=42)
+result = Backtest(market).run(LongShortRank(feature='mom_1m'))
+print(f"OOS Sharpe: {result.oos_sharpe:.3f}")
+```
+
+## Graded submission
+
+```python
+from convexpi.lab import Strategy, Grader
+import numpy as np
+
+class MyStrategy(Strategy):
+    def on_day(self, day, features, prices, portfolio):
+        sig = features['mom_1m']
+        total = np.abs(sig).sum()
+        return sig / total if total > 0 else np.zeros(len(prices))
+
+report = Grader().grade(MyStrategy)
+print(f"IS Sharpe: {report.is_sharpe:.3f}  OOS Sharpe: {report.oos_sharpe:.3f}")
+print(f"Overfitting ratio: {report.overfitting_ratio:.2%}")
+```
+
+## Features
+
+- Synthetic equity panel with planted alpha signals of known strength
+- Walk-forward backtester with transaction costs and turnover limits
+- Hidden-holdout grader — OOS data never seen during development
+- Alpha discovery detection — did you find the planted signal or fit noise?
+- 19 canonical strategy implementations (momentum, value, quality, size, risk-based)
+- Real-data mode: Ken French factors, FRED macro, yfinance prices (optional)
+- Anomaly graveyard: pre/post-publication Sharpe decay for 6 canonical factors
+- Forward paper-trading scorer (nightly, via GitHub Actions)
+
+## Optional dependencies
+
+```bash
+pip install "convexpi-lab[real-data]"   # yfinance + pandas-datareader
+pip install "convexpi-lab[deploy]"      # supabase + sentry (grader worker)
+```
+
+## License
+
+MIT © Shane Conway

convexpi_lab-0.1.0/README.md

@@ -0,0 +1,58 @@
+# convexpi-lab
+
+Synthetic equity panel generator, walk-forward backtester, and anti-overfitting grader for quantitative finance education and research.
+
+```bash
+pip install convexpi-lab
+```
+
+Part of the [ConvexPi](https://convexpi.ai) platform. See also [convexpi-arena](https://github.com/convexpi/arena) for the live exchange simulator.
+
+## Quick start
+
+```python
+from convexpi.lab import SyntheticMarket, Backtest, LongShortRank
+
+market = SyntheticMarket(n_stocks=50, n_days=756, seed=42)
+result = Backtest(market).run(LongShortRank(feature='mom_1m'))
+print(f"OOS Sharpe: {result.oos_sharpe:.3f}")
+```
+
+## Graded submission
+
+```python
+from convexpi.lab import Strategy, Grader
+import numpy as np
+
+class MyStrategy(Strategy):
+    def on_day(self, day, features, prices, portfolio):
+        sig = features['mom_1m']
+        total = np.abs(sig).sum()
+        return sig / total if total > 0 else np.zeros(len(prices))
+
+report = Grader().grade(MyStrategy)
+print(f"IS Sharpe: {report.is_sharpe:.3f}  OOS Sharpe: {report.oos_sharpe:.3f}")
+print(f"Overfitting ratio: {report.overfitting_ratio:.2%}")
+```
+
+## Features
+
+- Synthetic equity panel with planted alpha signals of known strength
+- Walk-forward backtester with transaction costs and turnover limits
+- Hidden-holdout grader — OOS data never seen during development
+- Alpha discovery detection — did you find the planted signal or fit noise?
+- 19 canonical strategy implementations (momentum, value, quality, size, risk-based)
+- Real-data mode: Ken French factors, FRED macro, yfinance prices (optional)
+- Anomaly graveyard: pre/post-publication Sharpe decay for 6 canonical factors
+- Forward paper-trading scorer (nightly, via GitHub Actions)
+
+## Optional dependencies
+
+```bash
+pip install "convexpi-lab[real-data]"   # yfinance + pandas-datareader
+pip install "convexpi-lab[deploy]"      # supabase + sentry (grader worker)
+```
+
+## License
+
+MIT © Shane Conway

convexpi_lab-0.1.0/deploy/Dockerfile.grader

@@ -0,0 +1,21 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+COPY pyproject.toml .
+COPY src/ src/
+COPY deploy/grader_worker.py deploy/grader_worker.py
+RUN pip install --no-cache-dir -e .
+
+# Optional: install Docker CLI so the grader can launch sandboxed subcontainers.
+# Set GRADER_DOCKER_IMAGE=<this image tag> in Railway env vars to enable Docker-in-Docker mode.
+# Without it the grader falls back to a plain subprocess (less secure but functional).
+# RUN apt-get update && apt-get install -y docker.io && rm -rf /var/lib/apt/lists/*
+
+# Required env vars (set in Railway):
+#   SUPABASE_URL, SUPABASE_SERVICE_KEY, MARKET_SEED
+# Optional:
+#   MARKET_N_STOCKS, MARKET_N_DAYS, POLL_SECONDS, GRADE_TIMEOUT
+#   GRADER_DOCKER_IMAGE  — set to enable Docker sandbox isolation
+#   SENTRY_DSN           — set to enable Sentry error monitoring
+
+CMD ["python", "deploy/grader_worker.py"]

convexpi_lab-0.1.0/deploy/compute_anomaly_stats.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+"""
+compute_anomaly_stats.py — Fetch French factor data and write anomaly-stats.json.
+
+Run this to refresh web/public/anomaly-stats.json. The file is committed to
+the repo and read by the /anomalies web page at build time. GitHub Actions
+runs this monthly so the OOS sample grows automatically.
+
+Usage:
+    python deploy/compute_anomaly_stats.py
+    python deploy/compute_anomaly_stats.py --no-monthly   # skip sparkline data
+    python deploy/compute_anomaly_stats.py --out path/to/anomaly-stats.json
+"""
+
+import argparse
+import json
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+from convexpi.lab.anomalies import compute_all
+
+
+def main():
+    p = argparse.ArgumentParser(description="Compute anomaly stats and write JSON")
+    p.add_argument(
+        "--out",
+        default=str(Path(__file__).parent.parent / "web" / "public" / "anomaly-stats.json"),
+    )
+    p.add_argument("--no-monthly", action="store_true",
+                   help="Skip monthly sparkline data (faster)")
+    args = p.parse_args()
+
+    print("Fetching French factor data…")
+    stats = compute_all(include_monthly=not args.no_monthly)
+
+    payload = {
+        "updated_at": datetime.now(tz=timezone.utc).isoformat(),
+        "source":     "Kenneth French Data Library (mba.tuck.dartmouth.edu)",
+        "anomalies":  stats,
+    }
+
+    out = Path(args.out)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(json.dumps(payload, indent=2))
+    print(f"Written {len(stats)} anomalies to {out}")
+
+    for s in stats:
+        decay_str = f"{s['decay_pct']:+.1f}%" if s['decay_pct'] != 0 else "N/A"
+        print(f"  {s['name']:<22} IS={s['is_sharpe']:>6.3f}  "
+              f"OOS={s['oos_sharpe']:>6.3f}  decay={decay_str}  [{s['status']}]")
+
+
+if __name__ == "__main__":
+    main()

convexpi_lab-0.1.0/deploy/forward_runner.py

@@ -0,0 +1,264 @@
+"""
+forward_runner.py — Nightly forward paper-trading evaluator.
+
+For each completed submission, runs the strategy on a fresh synthetic market
+window (seeded by today's date) and upserts one row into forward_scores.
+The leaderboard then shows rolling forward Sharpe alongside backtest Sharpe.
+
+Run once per day (cron, Railway cron service, or GitHub Actions schedule):
+    python deploy/forward_runner.py
+
+Required env vars (same as grader_worker):
+    SUPABASE_URL         — your project URL
+    SUPABASE_SERVICE_KEY — service role key (bypasses RLS)
+    MARKET_SEED_BASE     — integer base seed (default 1000); daily seed = base + days_since_epoch
+
+Optional:
+    FORWARD_WINDOW_DAYS  — trading days per evaluation window (default 60)
+    FORWARD_N_STOCKS     — stocks in each daily market (default 100; smaller = faster)
+    DISCORD_WEBHOOK_URL  — post a daily summary embed
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import subprocess
+import sys
+import tempfile
+import textwrap
+import time
+import traceback
+import urllib.request
+import urllib.error
+from datetime import date, timedelta
+from pathlib import Path
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s %(levelname)s %(message)s",
+    datefmt="%Y-%m-%dT%H:%M:%SZ",
+    stream=sys.stdout,
+)
+log = logging.getLogger("forward_runner")
+
+SUPABASE_URL    = os.environ["SUPABASE_URL"]
+SUPABASE_KEY    = os.environ["SUPABASE_SERVICE_KEY"]
+SEED_BASE       = int(os.environ.get("MARKET_SEED_BASE", "1000"))
+WINDOW_DAYS     = int(os.environ.get("FORWARD_WINDOW_DAYS", "60"))
+N_STOCKS        = int(os.environ.get("FORWARD_N_STOCKS", "100"))
+TIMEOUT_SECS    = int(os.environ.get("GRADE_TIMEOUT", "120"))
+DISCORD_WEBHOOK = os.environ.get("DISCORD_WEBHOOK_URL", "")
+
+PKG_PATH = str(Path(__file__).parent.parent / "src")
+
+# Seed is deterministic per calendar date so re-runs are idempotent
+EPOCH = date(2020, 1, 1)
+
+
+def date_seed(run_date: date) -> int:
+    return SEED_BASE + (run_date - EPOCH).days
+
+
+# ---------------------------------------------------------------------------
+# Supabase helpers
+# ---------------------------------------------------------------------------
+
+def _headers() -> dict:
+    return {
+        "apikey": SUPABASE_KEY,
+        "Authorization": f"Bearer {SUPABASE_KEY}",
+        "Content-Type": "application/json",
+        "Prefer": "return=representation",
+    }
+
+
+def _req(method: str, path: str, body: dict | None = None):
+    url = f"{SUPABASE_URL}/rest/v1{path}"
+    data = json.dumps(body).encode() if body else None
+    req = urllib.request.Request(url, data=data, headers=_headers(), method=method)
+    try:
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            return json.loads(resp.read())
+    except urllib.error.HTTPError as e:
+        log.error("supabase %s %s → %s: %s", method, path, e.code, e.read().decode()[:200])
+        return None
+    except Exception as exc:
+        log.error("supabase %s %s → %s", method, path, exc)
+        return None
+
+
+def fetch_completed_submissions() -> list[dict]:
+    result = _req("GET", "/submissions?status=eq.completed&select=id,cohort_id,code&limit=500")
+    return result or []
+
+
+def already_scored(submission_id: str, run_date: date) -> bool:
+    result = _req("GET", f"/forward_scores?submission_id=eq.{submission_id}&run_date=eq.{run_date}&select=id")
+    return bool(result)
+
+
+def upsert_score(submission_id: str, run_date: date, seed: int, metrics: dict) -> None:
+    _req("POST", "/forward_scores", {
+        "submission_id":  submission_id,
+        "run_date":       str(run_date),
+        "forward_sharpe": metrics.get("oos_sharpe"),
+        "forward_return": metrics.get("oos_annual_return"),
+        "forward_max_dd": metrics.get("oos_max_dd"),
+        "market_seed":    seed,
+        "window_days":    WINDOW_DAYS,
+    })
+
+
+# ---------------------------------------------------------------------------
+# Runner template (reuses grader runner pattern)
+# ---------------------------------------------------------------------------
+
+RUNNER_TEMPLATE = textwrap.dedent("""\
+    import sys, json
+    sys.path.insert(0, {pkg_path!r})
+
+    from convexpi.lab.synth import SyntheticMarket
+    from convexpi.lab.grader import Grader
+
+    {user_code}
+
+    market = SyntheticMarket(
+        n_stocks={n_stocks},
+        n_days={n_days},
+        seed={seed},
+    )
+    report = Grader(market).evaluate(MyStrategy())
+    result = {{
+        "oos_sharpe":        report.oos_sharpe,
+        "oos_annual_return": report.oos_annual_return,
+        "oos_max_dd":        report.oos_max_dd,
+    }}
+    print("__RESULT__:" + json.dumps(result))
+""")
+
+
+def evaluate_submission(sub_id: str, code: str, seed: int) -> dict | None:
+    runner = RUNNER_TEMPLATE.format(
+        pkg_path=PKG_PATH,
+        user_code=code,
+        n_stocks=N_STOCKS,
+        n_days=WINDOW_DAYS + 20,   # small buffer for IS warmup
+        seed=seed,
+    )
+    with tempfile.TemporaryDirectory() as tmpdir:
+        script = Path(tmpdir) / "forward_runner.py"
+        script.write_text(runner)
+        try:
+            result = subprocess.run(
+                [sys.executable, str(script)],
+                capture_output=True, text=True,
+                timeout=TIMEOUT_SECS,
+                cwd=tmpdir,
+            )
+        except subprocess.TimeoutExpired:
+            log.warning("submission=%s forward eval timed out", sub_id[:8])
+            return None
+
+    if result.returncode != 0 or "__RESULT__:" not in result.stdout:
+        log.warning("submission=%s forward eval error: %s", sub_id[:8], result.stderr[:200])
+        return None
+
+    try:
+        json_str = result.stdout.split("__RESULT__:")[1].strip().split("\n")[0]
+        return json.loads(json_str)
+    except Exception:
+        log.error("submission=%s could not parse forward output", sub_id[:8])
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Discord summary
+# ---------------------------------------------------------------------------
+
+def _discord_post(payload: dict) -> None:
+    if not DISCORD_WEBHOOK:
+        return
+    data = json.dumps(payload).encode()
+    req = urllib.request.Request(
+        DISCORD_WEBHOOK, data=data,
+        headers={"Content-Type": "application/json"}, method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=5):
+            pass
+    except Exception as exc:
+        log.warning("discord webhook failed: %s", exc)
+
+
+def post_daily_summary(run_date: date, n_scored: int, n_skipped: int, n_failed: int,
+                       best: dict | None) -> None:
+    lines = [
+        f"Scored **{n_scored}** submissions   skipped {n_skipped}   failed {n_failed}",
+    ]
+    if best:
+        lines.append(
+            f"Best forward Sharpe: **{best['sharpe']:.3f}** (submission `{best['sub_id'][:8]}`)"
+        )
+    _discord_post({
+        "embeds": [{
+            "title": f"Forward paper-trading — {run_date}",
+            "color": 0x5865F2,
+            "description": "\n".join(lines),
+            "footer": {"text": "ConvexPi forward runner"},
+        }]
+    })
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def main() -> None:
+    run_date = date.today()
+    seed     = date_seed(run_date)
+    log.info("forward runner started  date=%s  seed=%d  window=%d  stocks=%d",
+             run_date, seed, WINDOW_DAYS, N_STOCKS)
+
+    submissions = fetch_completed_submissions()
+    log.info("found %d completed submissions", len(submissions))
+
+    n_scored = n_skipped = n_failed = 0
+    best: dict | None = None
+
+    for sub in submissions:
+        sub_id    = sub["id"]
+        code      = sub.get("code", "")
+
+        if already_scored(sub_id, run_date):
+            log.info("submission=%s already scored for %s — skipping", sub_id[:8], run_date)
+            n_skipped += 1
+            continue
+
+        t0 = time.monotonic()
+        metrics = evaluate_submission(sub_id, code, seed)
+        elapsed = time.monotonic() - t0
+
+        if metrics is None:
+            n_failed += 1
+            continue
+
+        upsert_score(sub_id, run_date, seed, metrics)
+        sharpe = metrics.get("oos_sharpe") or 0.0
+        log.info("submission=%s  forward_sharpe=%.3f  elapsed=%.1fs", sub_id[:8], sharpe, elapsed)
+        n_scored += 1
+
+        if best is None or sharpe > best["sharpe"]:
+            best = {"sub_id": sub_id, "sharpe": sharpe}
+
+    log.info("done  scored=%d  skipped=%d  failed=%d", n_scored, n_skipped, n_failed)
+    post_daily_summary(run_date, n_scored, n_skipped, n_failed, best)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception:
+        log.error("forward runner crashed:\n%s", traceback.format_exc())
+        sys.exit(1)