terminex 0.4.0__py3-none-any.whl

terminex/__init__.py

@@ -0,0 +1 @@
+"""terminex — live FX rates in the terminal."""

terminex/__main__.py

@@ -0,0 +1,10 @@
+"""Entry point for ``python -m terminex``."""
+
+from __future__ import annotations
+
+import sys
+
+from .app import main
+
+if __name__ == "__main__":
+    sys.exit(main())

terminex/alert_engine.py

@@ -0,0 +1,69 @@
+"""Alert evaluation against live snapshots.
+
+Holds in-memory ``last_price`` per (asset_class, symbol) to detect
+threshold *crossings* rather than firing every tick while the
+condition stays true.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+from dataclasses import dataclass
+
+from . import alerts as alerts_dao
+from .alerts import Alert, _row_to_alert
+from .quote import Snapshot
+
+
+@dataclass(frozen=True)
+class FireEvent:
+    alert: Alert
+    price: float
+
+
+class AlertEngine:
+    def __init__(self, conn: sqlite3.Connection) -> None:
+        self.conn = conn
+        self._last_price: dict[tuple[str, str], float] = {}
+
+    def evaluate(self, snapshot: Snapshot, asset_class: str) -> list[FireEvent]:
+        quote_by_sym = {q.symbol: q.price for q in snapshot.quotes}
+        # Only load alerts for this asset_class
+        rows = self.conn.execute(
+            """
+            SELECT * FROM alerts
+            WHERE active = 1 AND asset_class = ?
+            """,
+            (asset_class,),
+        ).fetchall()
+        fires: list[FireEvent] = []
+        for row in rows:
+            alert = _row_to_alert(row)
+            price = quote_by_sym.get(alert.symbol)
+            if price is None:
+                continue
+            key = (asset_class, alert.symbol)
+            prev = self._last_price.get(key)
+            triggered = _is_triggered(alert, price, prev)
+            if triggered:
+                alerts_dao.record_fire(self.conn, alert.id, price)
+                if not alert.recurring:
+                    alerts_dao.deactivate(self.conn, alert.id)
+                fires.append(FireEvent(alert=alert, price=price))
+        # update last-seen prices for every symbol in this snapshot
+        for sym, price in quote_by_sym.items():
+            self._last_price[(asset_class, sym)] = price
+        return fires
+
+
+def _is_triggered(alert: Alert, price: float, prev: float | None) -> bool:
+    if alert.op == ">":
+        if price <= alert.threshold:
+            return False
+        # first observation OR prev did not satisfy the condition
+        return prev is None or prev <= alert.threshold
+    if alert.op == "<":
+        if price >= alert.threshold:
+            return False
+        return prev is None or prev >= alert.threshold
+    return False

terminex/alerts.py

@@ -0,0 +1,117 @@
+"""Alert dataclass and DAO.
+
+An alert fires when ``price`` crosses ``threshold`` in the ``op``
+direction. Non-recurring alerts auto-deactivate on fire; recurring
+ones stay active (but only fire again after the price leaves the
+triggered region, so we don't spam).
+"""
+
+from __future__ import annotations
+
+import sqlite3
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Literal
+
+Op = Literal[">", "<"]
+
+
+@dataclass(frozen=True)
+class Alert:
+    id: int
+    asset_class: str
+    symbol: str
+    op: Op
+    threshold: float
+    recurring: bool
+    active: bool
+    created_at: str
+    last_fired_at: str | None
+
+
+def _now_utc_iso() -> str:
+    return datetime.now(tz=timezone.utc).isoformat(timespec="seconds")
+
+
+def create(
+    conn: sqlite3.Connection,
+    *,
+    asset_class: str,
+    symbol: str,
+    op: Op,
+    threshold: float,
+    recurring: bool = False,
+) -> Alert:
+    cur = conn.execute(
+        """
+        INSERT INTO alerts
+          (asset_class, symbol, op, threshold, recurring, active, created_at)
+        VALUES (?, ?, ?, ?, ?, 1, ?)
+        """,
+        (asset_class, symbol, op, threshold, int(recurring), _now_utc_iso()),
+    )
+    return get(conn, cur.lastrowid)
+
+
+def get(conn: sqlite3.Connection, alert_id: int) -> Alert:
+    row = conn.execute(
+        "SELECT * FROM alerts WHERE id = ?", (alert_id,)
+    ).fetchone()
+    if row is None:
+        raise KeyError(alert_id)
+    return _row_to_alert(row)
+
+
+def list_active(conn: sqlite3.Connection) -> list[Alert]:
+    rows = conn.execute(
+        "SELECT * FROM alerts WHERE active = 1 ORDER BY id"
+    ).fetchall()
+    return [_row_to_alert(r) for r in rows]
+
+
+def list_all(conn: sqlite3.Connection) -> list[Alert]:
+    rows = conn.execute("SELECT * FROM alerts ORDER BY active DESC, id").fetchall()
+    return [_row_to_alert(r) for r in rows]
+
+
+def delete(conn: sqlite3.Connection, alert_id: int) -> bool:
+    cur = conn.execute("DELETE FROM alerts WHERE id = ?", (alert_id,))
+    return cur.rowcount > 0
+
+
+def deactivate(conn: sqlite3.Connection, alert_id: int) -> None:
+    conn.execute("UPDATE alerts SET active = 0 WHERE id = ?", (alert_id,))
+
+
+def record_fire(
+    conn: sqlite3.Connection, alert_id: int, price: float
+) -> None:
+    ts = _now_utc_iso()
+    conn.execute(
+        "INSERT INTO fires (alert_id, fired_at, price) VALUES (?, ?, ?)",
+        (alert_id, ts, price),
+    )
+    conn.execute(
+        "UPDATE alerts SET last_fired_at = ? WHERE id = ?",
+        (ts, alert_id),
+    )
+
+
+def count_active(conn: sqlite3.Connection) -> int:
+    return conn.execute(
+        "SELECT COUNT(*) FROM alerts WHERE active = 1"
+    ).fetchone()[0]
+
+
+def _row_to_alert(row: sqlite3.Row) -> Alert:
+    return Alert(
+        id=row["id"],
+        asset_class=row["asset_class"],
+        symbol=row["symbol"],
+        op=row["op"],
+        threshold=row["threshold"],
+        recurring=bool(row["recurring"]),
+        active=bool(row["active"]),
+        created_at=row["created_at"],
+        last_fired_at=row["last_fired_at"],
+    )

terminex/alerts_ui.py

@@ -0,0 +1,129 @@
+"""Rendering for alert creation modal and alert list view."""
+
+from __future__ import annotations
+
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from . import theme
+from .alerts import Alert
+
+
+def render_alert_new_panel(draft: dict) -> Panel:
+    table = Table(show_header=False, box=None, padding=(0, 1), expand=False)
+    table.add_column("")
+
+    asset_class = draft["asset_class"]
+    symbol = draft["symbol"]
+    current = draft["current_price"]
+
+    table.add_row(
+        Text(
+            f"Create alert on {asset_class.upper()}:{symbol}  "
+            f"(current: {_fmt(current)})",
+            style=f"bold {theme.ACCENT}",
+        )
+    )
+    table.add_row("")
+
+    # threshold line
+    line = Text()
+    line.append("  Condition:  price is  ", style=theme.MUTED)
+    line.append(draft["op"], style=f"bold {theme.WARN}")
+    line.append("  ", style="")
+    line.append(draft["threshold_buffer"], style="bold white")
+    line.append("▏", style=f"bold {theme.WARN}")
+    table.add_row(line)
+
+    recurring_line = Text()
+    recurring_line.append("  Recurring: ", style=theme.MUTED)
+    recurring_line.append(
+        "yes" if draft["recurring"] else "no",
+        style=f"bold {theme.ACCENT}" if draft["recurring"] else theme.MUTED,
+    )
+    table.add_row(recurring_line)
+
+    table.add_row("")
+    if draft.get("error"):
+        table.add_row(Text(draft["error"], style=theme.ERROR))
+        table.add_row("")
+    table.add_row(
+        Text(
+            "0-9 . edit threshold  ·  < >  toggle op  ·  r  toggle recurring",
+            style=theme.MUTED,
+        )
+    )
+    table.add_row(
+        Text("Enter to create · Esc to cancel", style=theme.MUTED)
+    )
+    return Panel(
+        table,
+        title="terminex — new alert",
+        title_align="left",
+        border_style=theme.PANEL_BORDER_WARN,
+        padding=(1, 2),
+    )
+
+
+def render_alert_list_panel(
+    alerts: list[Alert], delete_buffer: str = ""
+) -> Panel:
+    if not alerts:
+        inner: Table | Text = Text("No alerts defined.", style=theme.MUTED)
+    else:
+        tbl = Table(show_header=True, box=None, padding=(0, 2), expand=False)
+        tbl.add_column("#", style=theme.MUTED, justify="right")
+        tbl.add_column("Status", style=theme.MUTED)
+        tbl.add_column("Asset", style=theme.MUTED)
+        tbl.add_column("Symbol", style="bold")
+        tbl.add_column("Condition")
+        tbl.add_column("Mode", style=theme.MUTED)
+        tbl.add_column("Last fired", style=theme.MUTED)
+        for a in alerts:
+            status = Text(
+                "active" if a.active else "done",
+                style=theme.UP if a.active else theme.MUTED,
+            )
+            condition = Text(
+                f"{a.op} {a.threshold:g}", style=f"bold {theme.WARN}"
+            )
+            mode = "recurring" if a.recurring else "once"
+            last = a.last_fired_at.split("T")[0] if a.last_fired_at else "—"
+            tbl.add_row(
+                str(a.id), status, a.asset_class, a.symbol, condition, mode, last
+            )
+        inner = tbl
+
+    body = Table(show_header=False, box=None, padding=(0, 0), expand=False)
+    body.add_column("")
+    body.add_row(inner)
+    body.add_row("")
+    # delete prompt
+    prompt = Text()
+    prompt.append("delete ID:  ", style=f"bold {theme.ACCENT}")
+    prompt.append(delete_buffer, style="bold white")
+    prompt.append("▏", style=f"bold {theme.WARN}")
+    body.add_row(prompt)
+    body.add_row("")
+    body.add_row(
+        Text(
+            "digits build ID  ·  Enter deletes  ·  Esc to close",
+            style=theme.MUTED,
+        )
+    )
+    return Panel(
+        body,
+        title="terminex — alerts",
+        title_align="left",
+        border_style=theme.PANEL_BORDER_NEUTRAL,
+        padding=(1, 2),
+    )
+
+
+def _fmt(value: float) -> str:
+    if value >= 1000:
+        return f"{value:,.2f}"
+    if value >= 1:
+        return f"{value:.4f}"
+    return f"{value:.6f}"