31 posts
A practical engineering roadmap for building a quant-trading platform around a real GitHub project: Python project structure, A-share rules, data layers, factors, backtesting, paper trading, alerts, daily runs, and operations.
Article 45 adds OpsRunbook, turning execution decisions into operator-readable steps, and reviews the progress made in articles 41-45.
Article 44 adds ExecutionDecision, centralizing the execution judgment for ready, dry-run-ready, and blocked states so the command layer cannot accidentally trigger real paper-trading side effects.
Article 43 adds DailyRunCommandResponse, wrapping daily-run status, summary message, artifact path, and exit code into an object that the command layer can return directly.
Article 42 adds DailyRunArtifact, writing the daily-run plan's summary, request, failed checks, and actions into JSON as stable evidence for debugging and archival.
Article 41 adds DailyRunSummary outside DailyRunPlan, compressing daily-run status, symbol count, failed checks, and execution judgment into a log-friendly and CLI-friendly summary line.
Article 40 composes daily requests, operations checklists, run results, and failure actions into a daily run plan, then reviews the progress across articles 36-40.
Article 39 adds a failure-action policy that maps failed checks such as run_window, data_gaps, and run_health into concrete next-step suggestions.
Article 38 reads the daily report archive directory and generates index entries with trade date, status, and path, making historical reports easier to query and display.
Article 37 converts the operations checklist into a daily run result, distinguishes ready, dry-run-ready, and blocked, and keeps failed check names for later action mapping.
Article 36 adds a daily run request object, collecting trade date, generation time, required symbol list, and dry-run flag into one boundary before building a real runtime entry point.
Article 35 summarizes the run window, history summary, data gaps, and health report into an operations checklist, then reviews the progress made in articles 31-35.
Article 34 compares required symbols with a price snapshot and generates blocker-level data-gap plans so strategies do not silently run with missing prices.
Article 33 reads daily archived reports and calculates report count, latest status, blocker count, and notification success rate, moving paper trading from single-day output to a history view.
Article 32 writes alert messages, run health reports, and review records into stable JSON archives, laying the foundation for paper-trading audits and history statistics.
Article 31 adds a run window to the paper-trading daily flow, preventing jobs from running at the wrong time and returning the next allowed run time.
Article 30 summarizes price snapshots, production checks, and notification receipts into a run health report, classifying each daily paper-trading run as ok, warning, or blocker.
Article 29 adds a target-weight policy that converts candidate stocks into equal-weight targets with controlled gross exposure and normalization, giving rebalance plans more stable input.
Article 28 adds a price-provider protocol and a static price provider, turning the daily paper-trading last_prices dictionary into replaceable input for later real market-data integration.
Article 27 implements a file-based notification channel that writes paper-trading daily reports and receipts into JSONL as a verifiable substitute before real notification platforms are connected.
Article 26 adds a paper-trading notification-channel abstraction, stabilizing the send interface and receipt structure before connecting files, Lark, email, or other channels.
Article 25 adds paper-trading production checks for cash, market prices, target weights, daily reports, and review records, then reviews articles 21-25.
Article 24 saves and restores paper-trading account state with JSON files, persisting only cash and positions instead of derived snapshots so the daily flow can continue after restarts.
Article 23 links account snapshots, risk checks, rebalance plans, recommendation summaries, daily alert messages, and review records into one testable paper-trading daily cycle.
Article 22 adds paper-trading review records, saving daily equity, cash ratio, risk severity, and recommendation action as sortable entries with multi-day summaries.
Article 21 combines account snapshots, risk reports, and rebalance plans into HOLD, REBALANCE, and REDUCE_RISK actions so paper-trading output is easier to review and alert on.
Article 20 combines account snapshots, risk reports, and rebalance plans into paper-trading daily report text, leaving a stable message format for Lark, email, or other notification channels.
Article 19 implements the first rebalance-plan layer, converting gaps between current and target weights into A-share board-lot buy and sell suggestions without modifying the account.
Article 18 implements paper-trading risk checks based on account snapshots, validating total exposure, cash buffer, and single-stock weight with readable violations.
Article 17 builds account snapshots on top of the paper-trading ledger, calculating cash ratio, position market value, floating PnL, and weights as unified input for risk controls and notifications.
Article 16 enters paper trading by adding accounts, positions, and execution results, making buy, sell, cash, and market-value updates testable ledger logic.