dennisthiessenandClaude Fable 5
ba2df8b9fd
The manual paper book only contains trades taken by hand, inside a 20
minute window, on days someone was available. The backtest that validated
this strategy auto-takes the top-ranked qualified setups up to capacity
every session. The forward record was therefore measuring strategy plus
discretion plus availability -- and degrading silently on busy days.
The shadow book closes that gap: it mirrors the backtest's selection rule
(top strategy_rank qualified, up to capacity, 1% fixed-fractional risk)
and shares the manual book's exit policy, so the only difference between
the two books is which setups get taken. Selection ordering reuses the
strategy_rank the scanner already stores rather than recomputing it, so
the two cannot drift apart. It runs as a near-close pipeline step right
after the scan, marking entries at the same prices a human would see.
Gate-reset re-entry state is now scoped per book -- the books diverge as
soon as their entries differ, and each must see only its own stops.
Performance view rewritten around the comparison:
- three series (shadow, manual, SPY) from a new endpoint
- SPY changes from a per-trade cost-basis counterfactual to plain
buy-and-hold %, since one line has to serve two books
- headline stats are R-multiples, not currency: the books size
differently, so only R compares across them
- configurable start date, because the strategy has been revised
repeatedly and pre-cutover trades ran under rules that no longer
exist
Migration 024 also repairs the numeric weekday crons written by 023,
rewriting only rows still holding the broken form so hand-corrected
settings survive. Its literals are inlined because bound parameters
render as NULL under 'alembic upgrade --sql'.
The shadow book is opt-in and writes nothing until enabled. Verify its
first selections match a backtest of that day's cross-section before
trusting any point on the curve.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
123 lines
4.1 KiB
Python
123 lines
4.1 KiB
Python
"""Paper trades router — take, list, and close simulated trades."""
|
|
|
|
from fastapi import APIRouter, Depends, Query
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from app.dependencies import get_db, require_access, require_admin
|
|
from app.models.user import User
|
|
from app.schemas.common import APIEnvelope
|
|
from app.schemas.paper_trade import (
|
|
ExitPolicyUpdate,
|
|
PaperTradeClose,
|
|
PaperTradeCreate,
|
|
PaperTradeResponse,
|
|
)
|
|
from app.services import paper_trade_service
|
|
|
|
router = APIRouter(tags=["paper-trades"])
|
|
|
|
|
|
def _resp(trade, symbol: str, current_price=None) -> dict:
|
|
return PaperTradeResponse(
|
|
id=trade.id,
|
|
symbol=symbol,
|
|
direction=trade.direction,
|
|
entry_price=trade.entry_price,
|
|
shares=trade.shares,
|
|
stop_loss=trade.stop_loss,
|
|
target=trade.target,
|
|
status=trade.status,
|
|
opened_at=trade.opened_at,
|
|
close_price=trade.close_price,
|
|
closed_at=trade.closed_at,
|
|
current_price=current_price,
|
|
).model_dump(mode="json")
|
|
|
|
|
|
@router.get("/paper-trades", response_model=APIEnvelope)
|
|
async def list_paper_trades(
|
|
status: str | None = Query(default=None, pattern=r"^(open|closed)$"),
|
|
user: User = Depends(require_access),
|
|
db: AsyncSession = Depends(get_db),
|
|
) -> APIEnvelope:
|
|
rows = await paper_trade_service.list_trades(db, user.id, status=status)
|
|
data = [PaperTradeResponse(**r).model_dump(mode="json") for r in rows]
|
|
return APIEnvelope(status="success", data=data)
|
|
|
|
|
|
@router.get("/paper-trades/exit-policy", response_model=APIEnvelope)
|
|
async def read_exit_policy(
|
|
_user: User = Depends(require_access),
|
|
db: AsyncSession = Depends(get_db),
|
|
) -> APIEnvelope:
|
|
"""The active auto-exit policy for open paper trades (shown in the UI)."""
|
|
return APIEnvelope(status="success", data=await paper_trade_service.get_exit_policy(db))
|
|
|
|
|
|
@router.get("/paper-trades/equity-curve", response_model=APIEnvelope)
|
|
async def paper_trade_equity_curve(
|
|
user: User = Depends(require_access),
|
|
db: AsyncSession = Depends(get_db),
|
|
) -> APIEnvelope:
|
|
"""Daily cumulative P&L of the paper book vs the same dollars riding SPY."""
|
|
return APIEnvelope(
|
|
status="success", data=await paper_trade_service.equity_curve(db, user.id)
|
|
)
|
|
|
|
|
|
@router.get("/paper-trades/performance", response_model=APIEnvelope)
|
|
async def paper_trade_performance(
|
|
_user: User = Depends(require_access),
|
|
db: AsyncSession = Depends(get_db),
|
|
) -> APIEnvelope:
|
|
"""Shadow book vs discretionary book vs SPY since the configured start date."""
|
|
return APIEnvelope(
|
|
status="success", data=await paper_trade_service.performance_summary(db)
|
|
)
|
|
|
|
|
|
@router.put("/paper-trades/exit-policy", response_model=APIEnvelope)
|
|
async def write_exit_policy(
|
|
body: ExitPolicyUpdate,
|
|
_user: User = Depends(require_admin),
|
|
db: AsyncSession = Depends(get_db),
|
|
) -> APIEnvelope:
|
|
"""Change the auto-exit policy (admin)."""
|
|
data = await paper_trade_service.set_exit_policy(
|
|
db,
|
|
mode=body.mode,
|
|
trailing_pct=body.trailing_pct,
|
|
atr_multiplier=body.atr_multiplier,
|
|
hold_days=body.hold_days,
|
|
)
|
|
return APIEnvelope(status="success", data=data)
|
|
|
|
|
|
@router.post("/paper-trades", response_model=APIEnvelope, status_code=201)
|
|
async def create_paper_trade(
|
|
body: PaperTradeCreate,
|
|
user: User = Depends(require_access),
|
|
db: AsyncSession = Depends(get_db),
|
|
) -> APIEnvelope:
|
|
trade = await paper_trade_service.create_trade(
|
|
db, user.id,
|
|
symbol=body.symbol,
|
|
direction=body.direction,
|
|
entry_price=body.entry_price,
|
|
shares=body.shares,
|
|
stop_loss=body.stop_loss,
|
|
target=body.target,
|
|
)
|
|
return APIEnvelope(status="success", data=_resp(trade, body.symbol.strip().upper()))
|
|
|
|
|
|
@router.post("/paper-trades/{trade_id}/close", response_model=APIEnvelope)
|
|
async def close_paper_trade(
|
|
trade_id: int,
|
|
body: PaperTradeClose,
|
|
user: User = Depends(require_access),
|
|
db: AsyncSession = Depends(get_db),
|
|
) -> APIEnvelope:
|
|
trade = await paper_trade_service.close_trade(db, user.id, trade_id, body.close_price)
|
|
return APIEnvelope(status="success", data={"id": trade.id, "status": trade.status})
|