| """Position management and rolling mechanics. |
| |
| RollManager.check() takes an open position plus today's chain and returns |
| recommended actions with a concrete proposal (close / take-profit / stop / |
| roll out / roll down / roll out-and-down / roll out-and-up). |
| """ |
| from dataclasses import dataclass, field |
| from .pricing import bs_delta |
|
|
|
|
| @dataclass |
| class Position: |
| symbol: str |
| structure: str |
| legs: list |
| entry_credit: float = 0.0 |
| entry_date: str = "" |
| qty_sets: int = 1 |
|
|
|
|
| @dataclass |
| class RollAction: |
| action: str |
| reason: str |
| proposed_legs: list = field(default_factory=list) |
| urgency: str = "normal" |
|
|
|
|
| def _position_value(position, chain, horizon_expiry=None): |
| """Mark-to-market per share using current chain quotes (mid), back legs |
| valued at front expiry via BS when they outlive the horizon.""" |
| from .pricing import bs_price |
| from datetime import date, datetime, timezone |
| value = 0.0 |
| for kind, strike, expiry, side, qty in position.legs: |
| q = chain.get(strike, expiry, kind) |
| if q and q.mid > 0: |
| price = q.mid |
| else: |
| dte = (date.fromisoformat(expiry) - datetime.now(timezone.utc).date()).days |
| price = bs_price(chain.spot, strike, max(dte, 0.5) / 365.0, 0.30, kind) |
| value += side * qty * price |
| return value |
|
|
|
|
| def _short_deltas(position, chain): |
| """Current |delta| of each short leg.""" |
| out = [] |
| for kind, strike, expiry, side, qty in position.legs: |
| if side < 0: |
| q = chain.get(strike, expiry, kind) |
| d = abs(q.delta) if q and q.delta else 0.0 |
| if not d: |
| from .pricing import bs_delta as _bd |
| from datetime import date, datetime, timezone |
| dte = (date.fromisoformat(expiry) - datetime.now(timezone.utc).date()).days |
| d = abs(_bd(chain.spot, strike, max(dte, 0.5) / 365.0, 0.30, kind)) |
| out.append((kind, strike, expiry, d)) |
| return out |
|
|
|
|
| def _dte(expiry): |
| from datetime import date, datetime, timezone |
| return (date.fromisoformat(expiry) - datetime.now(timezone.utc).date()).days |
|
|
|
|
| def check(position, chain, rules): |
| """rules: profit_target_pct, stop_loss_mult, roll_dte, tested_delta.""" |
| actions = [] |
| value = _position_value(position, chain) |
| |
| pnl = (position.entry_credit - value) if position.entry_credit >= 0 else (value - position.entry_credit) |
| is_credit = position.entry_credit >= 0 |
| dte = min(_dte(e) for _, _, e, _, _ in position.legs) |
|
|
| |
| if is_credit and pnl >= rules["profit_target_pct"] * position.entry_credit: |
| actions.append(RollAction("close_profit", |
| f"captured {pnl / position.entry_credit:.0%} of entry credit " |
| f"(${pnl * 100:.2f}/set)", urgency="normal")) |
| if not is_credit and position.entry_credit < 0 and value > 0 and \ |
| (value - position.entry_credit) / (-position.entry_credit) >= rules["profit_target_pct"]: |
| actions.append(RollAction("close_profit", |
| f"debit spread up {pnl / -position.entry_credit:.0%} of entry debit")) |
| |
| if is_credit and value >= position.entry_credit * rules["stop_loss_mult"]: |
| actions.append(RollAction("close_stop", |
| f"unrealized loss ${-pnl * 100:.2f}/set exceeds " |
| f"{rules['stop_loss_mult']}x credit — cut it", |
| urgency="high")) |
| |
| if dte <= rules["roll_dte"]: |
| short_strikes = _short_deltas(position, chain) |
| tested = [s for s in short_strikes if s[3] >= rules["tested_delta"]] |
| if tested: |
| kind, strike, expiry, d = tested[0] |
| back = chain.expirations(min_dte=25, max_dte=60) |
| if not back or back[0] <= expiry: |
| actions.append(RollAction("close_stop" if pnl < 0 else "close_profit", |
| f"DTE {dte} <= {rules['roll_dte']} and no further expiry to roll to — close")) |
| else: |
| new_exp = back[0] |
| if pnl >= 0: |
| actions.append(RollAction("roll_out", |
| f"winning short {strike:g}{kind} at delta {d:.2f} — " |
| f"roll to {new_exp} to harvest more theta")) |
| elif kind == "P": |
| new_k = chain.nearest_strike(strike * 0.97, new_exp, kind) |
| if new_k: |
| actions.append(RollAction("roll_out_and_down", |
| f"tested put {strike:g} (delta {d:.2f}) — " |
| f"roll out-and-down to {new_exp} {new_k.strike:g}P", |
| proposed_legs=[("P", new_k.strike, new_exp, -1, 1)], |
| urgency="high")) |
| else: |
| new_k = chain.nearest_strike(strike * 1.03, new_exp, kind) |
| if new_k: |
| actions.append(RollAction("roll_out_and_up", |
| f"tested call {strike:g} (delta {d:.2f}) — " |
| f"roll out-and-up to {new_exp} {new_k.strike:g}C", |
| proposed_legs=[("C", new_k.strike, new_exp, -1, 1)], |
| urgency="high")) |
| else: |
| actions.append(RollAction("hold", |
| f"DTE {dte}, short deltas below {rules['tested_delta']} — " |
| f"let theta work")) |
| if not actions: |
| actions.append(RollAction("hold", f"DTE {dte}, inside all thresholds")) |
| return actions |
|
|
|
|
| DEFAULT_ROLL_RULES = { |
| "profit_target_pct": 0.50, |
| "stop_loss_mult": 2.0, |
| "roll_dte": 21, |
| "tested_delta": 0.40, |
| } |
|
|
