bu5hm4nn/vault-dash
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: prioritize lazy options loading and live overview wiring

Browse Source 
- queue OPS-001 Caddy route for vd1.uncloud.vpn
- lazy-load options expirations/chains per expiry
- wire overview to live quote data and persisted portfolio config
- extend browser test to verify live quote metadata
This commit is contained in:
Bu5hm4nn
2026-03-23 23:23:59 +01:00
parent d51fa05d5a
commit 133908dd36
6 changed files with 320 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
app/pages/common.py
View File

@@ -67,8 +67,8 @@ def strategy_catalog() -> list[dict[str, Any]]:
]
def quick_recommendations() -> list[dict[str, str]]:
portfolio = portfolio_snapshot()
def quick_recommendations(portfolio: dict[str, Any] | None = None) -> list[dict[str, str]]:
portfolio = portfolio or portfolio_snapshot()
ltv_gap = (portfolio["margin_call_ltv"] - portfolio["ltv_ratio"]) * 100
return [
{

125
app/pages/options.py
View File

@@ -11,19 +11,29 @@ from app.services.runtime import get_data_service
@ui.page("/options")
async def options_page() -> None:
chain_data = await get_data_service().get_options_chain("GLD")
chain = list(chain_data.get("rows") or [*chain_data.get("calls", []), *chain_data.get("puts", [])])
expiries = list(chain_data.get("expirations") or sorted({row["expiry"] for row in chain}))
strike_values = sorted({float(row["strike"]) for row in chain})
data_service = get_data_service()
expirations_data = await data_service.get_option_expirations("GLD")
expiries = list(expirations_data.get("expirations") or [])
default_expiry = expiries[0] if expiries else None
chain_data = await data_service.get_options_chain_for_expiry("GLD", default_expiry)
selected_expiry = {"value": expiries[0] if expiries else None}
strike_range = {
"min": strike_values[0] if strike_values else 0.0,
"max": strike_values[-1] if strike_values else 0.0,
chain_state = {
"data": chain_data,
"rows": list(chain_data.get("rows") or [*chain_data.get("calls", []), *chain_data.get("puts", [])]),
}
selected_expiry = {"value": chain_data.get("selected_expiry") or default_expiry}
selected_strategy = {"value": strategy_catalog()[0]["label"]}
chosen_contracts: list[dict[str, Any]] = []
def strike_bounds(rows: list[dict[str, Any]]) -> tuple[float, float]:
strike_values = sorted({float(row["strike"]) for row in rows})
if not strike_values:
return 0.0, 0.0
return strike_values[0], strike_values[-1]
initial_min_strike, initial_max_strike = strike_bounds(chain_state["rows"])
strike_range = {"min": initial_min_strike, "max": initial_max_strike}
with dashboard_page(
"Options Chain",
"Browse GLD contracts, filter by expiry and strike range, inspect Greeks, and attach contracts to hedge workflows.",
@@ -35,34 +45,17 @@ async def options_page() -> None:
):
ui.label("Filters").classes("text-lg font-semibold text-slate-900 dark:text-slate-100")
expiry_select = ui.select(expiries, value=selected_expiry["value"], label="Expiry").classes("w-full")
min_strike = ui.number(
"Min strike",
value=strike_range["min"],
min=strike_values[0] if strike_values else 0.0,
max=strike_values[-1] if strike_values else 0.0,
step=5,
).classes("w-full")
max_strike = ui.number(
"Max strike",
value=strike_range["max"],
min=strike_values[0] if strike_values else 0.0,
max=strike_values[-1] if strike_values else 0.0,
step=5,
).classes("w-full")
min_strike = ui.number("Min strike", value=strike_range["min"], step=5).classes("w-full")
max_strike = ui.number("Max strike", value=strike_range["max"], step=5).classes("w-full")
strategy_select = ui.select(
[item["label"] for item in strategy_catalog()],
value=selected_strategy["value"],
label="Add to hedge strategy",
).classes("w-full")
source_label = f"Source: {chain_data.get('source', 'unknown')}"
if chain_data.get("updated_at"):
source_label += f" · Updated {chain_data['updated_at']}"
ui.label(source_label).classes("text-xs text-slate-500 dark:text-slate-400")
if chain_data.get("error"):
ui.label(f"Options data unavailable: {chain_data['error']}").classes(
"text-xs text-amber-700 dark:text-amber-300"
)
source_html = ui.html("").classes("text-xs text-slate-500 dark:text-slate-400")
error_html = ui.html("").classes("text-xs text-amber-700 dark:text-amber-300")
loading_html = ui.html("").classes("text-xs text-sky-700 dark:text-sky-300")
selection_card = ui.card().classes(
"w-full rounded-2xl border border-slate-200 bg-white shadow-sm dark:border-slate-800 dark:bg-slate-900"
@@ -70,15 +63,27 @@ async def options_page() -> None:
chain_table = ui.html("").classes("w-full")
greeks = GreeksTable([])
quick_add = ui.card().classes(
"w-full rounded-2xl border border-slate-200 bg-white shadow-sm dark:border-slate-800 dark:bg-slate-900"
)
def sync_status() -> None:
current_data = chain_state["data"]
source_label = f"Source: {current_data.get('source', 'unknown')}"
if current_data.get("updated_at"):
source_label += f" · Updated {current_data['updated_at']}"
source_html.content = source_label
source_html.update()
error_message = current_data.get("error") or expirations_data.get("error")
error_html.content = f"Options data unavailable: {error_message}" if error_message else ""
error_html.update()
def filtered_rows() -> list[dict[str, Any]]:
if not selected_expiry["value"]:
return []
return [
row
for row in chain
if row["expiry"] == selected_expiry["value"]
and strike_range["min"] <= float(row["strike"]) <= strike_range["max"]
for row in chain_state["rows"]
if strike_range["min"] <= float(row["strike"]) <= strike_range["max"]
]
def render_selection() -> None:
@@ -100,10 +105,7 @@ async def options_page() -> None:
chosen_contracts.append(contract)
render_selection()
greeks.set_options(chosen_contracts[-6:])
ui.notify(
f"Added {contract['symbol']} to {selected_strategy['value']}",
color="positive",
)
ui.notify(f"Added {contract['symbol']} to {selected_strategy['value']}", color="positive")
def render_chain() -> None:
rows = filtered_rows()
@@ -125,7 +127,8 @@ async def options_page() -> None:
</thead>
<tbody>
"""
+ "".join(f"""
+ "".join(
f"""
<tr class='border-b border-slate-200 dark:border-slate-800'>
<td class='px-4 py-3 font-medium text-slate-900 dark:text-slate-100'>{row['symbol']}</td>
<td class='px-4 py-3 text-slate-600 dark:text-slate-300'>{row['type'].upper()}</td>
@@ -136,7 +139,9 @@ async def options_page() -> None:
<td class='px-4 py-3 text-slate-600 dark:text-slate-300'>Δ {float(row.get('delta', 0.0)):+.3f} · Γ {float(row.get('gamma', 0.0)):.3f} · Θ {float(row.get('theta', 0.0)):+.3f}</td>
<td class='px-4 py-3 text-sky-600 dark:text-sky-300'>Use quick-add buttons below</td>
</tr>
""" for row in rows)
"""
for row in rows
)
+ (
""
if rows
@@ -162,32 +167,48 @@ async def options_page() -> None:
).props("outline color=primary")
greeks.set_options(rows[:6])
quick_add = ui.card().classes(
"w-full rounded-2xl border border-slate-200 bg-white shadow-sm dark:border-slate-800 dark:bg-slate-900"
)
async def load_expiry_chain(expiry: str | None) -> None:
selected_expiry["value"] = expiry
loading_html.content = "Loading selected expiry…" if expiry else ""
loading_html.update()
next_chain = await data_service.get_options_chain_for_expiry("GLD", expiry)
chain_state["data"] = next_chain
chain_state["rows"] = list(next_chain.get("rows") or [*next_chain.get("calls", []), *next_chain.get("puts", [])])
min_value, max_value = strike_bounds(chain_state["rows"])
strike_range["min"] = min_value
strike_range["max"] = max_value
min_strike.value = min_value
max_strike.value = max_value
loading_html.content = ""
loading_html.update()
sync_status()
render_chain()
def update_filters() -> None:
selected_expiry["value"] = expiry_select.value
strike_range["min"] = float(min_strike.value or 0.0)
strike_range["max"] = float(max_strike.value or 0.0)
if strike_range["min"] > strike_range["max"]:
strike_range["min"], strike_range["max"] = (
strike_range["max"],
strike_range["min"],
)
strike_range["min"], strike_range["max"] = (strike_range["max"], strike_range["min"])
min_strike.value = strike_range["min"]
max_strike.value = strike_range["max"]
render_chain()
expiry_select.on_value_change(lambda _: update_filters())
async def on_expiry_change(event: Any) -> None:
await load_expiry_chain(event.value)
expiry_select.on_value_change(on_expiry_change)
min_strike.on_value_change(lambda _: update_filters())
max_strike.on_value_change(lambda _: update_filters())
def on_strategy_change(event) -> None:
selected_strategy["value"] = event.value # type: ignore[assignment]
def on_strategy_change(event: Any) -> None:
selected_strategy["value"] = event.value
render_selection()
strategy_select.on_value_change(on_strategy_change)
sync_status()
render_selection()
render_chain()

86
app/pages/overview.py
View File

@@ -1,48 +1,98 @@
from __future__ import annotations
from datetime import UTC, datetime
from nicegui import ui
from app.components import PortfolioOverview
from app.pages.common import (
dashboard_page,
portfolio_snapshot,
quick_recommendations,
recommendation_style,
strategy_catalog,
)
from app.models.portfolio import PortfolioConfig, get_portfolio_repository
from app.pages.common import dashboard_page, quick_recommendations, recommendation_style, strategy_catalog
from app.services.runtime import get_data_service
_REFERENCE_SPOT_PRICE = 215.0
_DEFAULT_CASH_BUFFER = 18_500.0
def _format_timestamp(value: str | None) -> str:
if not value:
return "Unavailable"
try:
timestamp = datetime.fromisoformat(value.replace("Z", "+00:00"))
except ValueError:
return value
return timestamp.astimezone(UTC).strftime("%Y-%m-%d %H:%M:%S UTC")
def _build_live_portfolio(config: PortfolioConfig, quote: dict[str, object]) -> dict[str, float | str]:
spot_price = float(quote.get("price", _REFERENCE_SPOT_PRICE))
configured_gold_value = float(config.gold_value)
estimated_units = configured_gold_value / _REFERENCE_SPOT_PRICE if _REFERENCE_SPOT_PRICE > 0 else 0.0
live_gold_value = estimated_units * spot_price
loan_amount = float(config.loan_amount)
margin_call_ltv = float(config.margin_threshold)
ltv_ratio = loan_amount / live_gold_value if live_gold_value > 0 else 0.0
return {
"spot_price": spot_price,
"gold_units": estimated_units,
"gold_value": live_gold_value,
"loan_amount": loan_amount,
"ltv_ratio": ltv_ratio,
"net_equity": live_gold_value - loan_amount,
"margin_call_ltv": margin_call_ltv,
"margin_call_price": loan_amount / (margin_call_ltv * estimated_units) if estimated_units > 0 else 0.0,
"cash_buffer": max(live_gold_value - configured_gold_value, 0.0) + _DEFAULT_CASH_BUFFER,
"hedge_budget": float(config.monthly_budget),
"quote_source": str(quote.get("source", "unknown")),
"quote_updated_at": str(quote.get("updated_at", "")),
}
@ui.page("/")
@ui.page("/overview")
def overview_page() -> None:
portfolio = portfolio_snapshot()
async def overview_page() -> None:
config = get_portfolio_repository().load()
data_service = get_data_service()
symbol = data_service.default_symbol
quote = await data_service.get_quote(symbol)
portfolio = _build_live_portfolio(config, quote)
quote_status = (
f"Live quote source: {portfolio['quote_source']} · "
f"Last updated {_format_timestamp(str(portfolio['quote_updated_at']))}"
)
with dashboard_page(
"Overview",
"Portfolio health, LTV risk, and quick strategy guidance for the current GLD-backed loan.",
"overview",
):
with ui.row().classes("w-full items-center justify-between gap-4 max-md:flex-col max-md:items-start"):
ui.label(quote_status).classes("text-sm text-slate-500 dark:text-slate-400")
ui.label(
f"Configured collateral baseline: ${config.gold_value:,.0f} · Loan ${config.loan_amount:,.0f}"
).classes("text-sm text-slate-500 dark:text-slate-400")
with ui.grid(columns=4).classes("w-full gap-4 max-lg:grid-cols-2 max-sm:grid-cols-1"):
summary_cards = [
(
"Spot Price",
f"${portfolio['spot_price']:,.2f}",
"GLD reference price",
f"{symbol} live quote via {portfolio['quote_source']}",
),
(
"Margin Call Price",
f"${portfolio['margin_call_price']:,.2f}",
"Implied trigger level",
"Implied trigger level from persisted portfolio settings",
),
(
"Cash Buffer",
f"${portfolio['cash_buffer']:,.0f}",
"Available liquidity",
"Base liquidity plus unrealized gain cushion vs configured baseline",
),
(
"Hedge Budget",
f"${portfolio['hedge_budget']:,.0f}",
"Approved premium budget",
"Monthly budget from saved settings",
),
]
for title, value, caption in summary_cards:
@@ -53,7 +103,7 @@ def overview_page() -> None:
ui.label(value).classes("text-3xl font-bold text-slate-900 dark:text-slate-50")
ui.label(caption).classes("text-sm text-slate-500 dark:text-slate-400")
portfolio_view = PortfolioOverview(margin_call_ltv=portfolio["margin_call_ltv"])
portfolio_view = PortfolioOverview(margin_call_ltv=float(portfolio["margin_call_ltv"]))
portfolio_view.update(portfolio)
with ui.row().classes("w-full gap-6 max-lg:flex-col"):
@@ -62,15 +112,15 @@ def overview_page() -> None:
):
with ui.row().classes("w-full items-center justify-between"):
ui.label("Current LTV Status").classes("text-lg font-semibold text-slate-900 dark:text-slate-100")
ui.label(f"Threshold {portfolio['margin_call_ltv'] * 100:.0f}%").classes(
ui.label(f"Threshold {float(portfolio['margin_call_ltv']) * 100:.0f}%").classes(
"rounded-full bg-rose-100 px-3 py-1 text-xs font-semibold text-rose-700 dark:bg-rose-500/15 dark:text-rose-300"
)
ui.linear_progress(
value=portfolio["ltv_ratio"] / portfolio["margin_call_ltv"],
value=float(portfolio["ltv_ratio"]) / max(float(portfolio["margin_call_ltv"]), 0.01),
show_value=False,
).props("color=warning track-color=grey-3 rounded")
ui.label(
f"Current LTV is {portfolio['ltv_ratio'] * 100:.1f}% with a margin buffer of {(portfolio['margin_call_ltv'] - portfolio['ltv_ratio']) * 100:.1f} percentage points."
f"Current LTV is {float(portfolio['ltv_ratio']) * 100:.1f}% with a margin buffer of {(float(portfolio['margin_call_ltv']) - float(portfolio['ltv_ratio'])) * 100:.1f} percentage points."
).classes("text-sm text-slate-600 dark:text-slate-300")
ui.label(
"Warning: if GLD approaches the margin-call price, collateral remediation or hedge monetization will be required."
@@ -93,7 +143,7 @@ def overview_page() -> None:
ui.label("Quick Strategy Recommendations").classes("text-xl font-semibold text-slate-900 dark:text-slate-100")
with ui.grid(columns=3).classes("w-full gap-4 max-lg:grid-cols-1"):
for rec in quick_recommendations():
for rec in quick_recommendations(portfolio):
with ui.card().classes(f"rounded-2xl border shadow-sm {recommendation_style(rec['tone'])}"):
ui.label(rec["title"]).classes("text-base font-semibold text-slate-900 dark:text-slate-100")
ui.label(rec["summary"]).classes("text-sm text-slate-600 dark:text-slate-300")