optionda 0.1.0__py3-none-any.whl

optionda/__init__.py

@@ -0,0 +1,3 @@
+"""optionda — terminal options desk (MODEL marks, frozen IV)."""
+
+__version__ = "0.1.0"

optionda/add_resolve.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from optionda.batch import read_batch_lines
+from optionda.occ import OccError, parse_leg_line
+
+
+def split_semi_separated(text: str) -> list[str]:
+    """Split 'A; B; C' into position lines (keeps spaces inside each part)."""
+    parts = [p.strip() for p in text.replace("\n", ";").split(";")]
+    return [p for p in parts if p and not p.startswith("#")]
+
+
+def read_interactive_lines(
+    *,
+    prompt_print=print,
+    line_input=input,
+) -> list[str]:
+    """Read pasted lines until a blank line or EOF (Ctrl+Z Enter on Windows)."""
+    prompt_print("Paste positions (one per line): ROOT YYMMDD STRIKE C|P xQTY @ cost")
+    prompt_print("Finish with an empty line, or Ctrl+Z then Enter (Windows).")
+    prompt_print("")
+    lines: list[str] = []
+    while True:
+        try:
+            line = line_input()
+        except EOFError:
+            break
+        if not line.strip():
+            break
+        if line.strip().startswith("#"):
+            continue
+        lines.append(line.strip())
+    return lines
+
+
+def _validated_line(token: str) -> str:
+    """Validate parseability but keep the original text (preserves @ cost)."""
+    parse_leg_line(token)
+    return token.strip()
+
+
+def resolve_add_lines(items: list[str]) -> list[str]:
+    """Normalize CLI tokens into one or more position lines.
+
+    Supports:
+      - single/multiple OCC symbols (with optional @ cost)
+      - one human line split across argv: INTC 261016 140 C @ 5.20
+      - semicolon-separated in one argv
+      - file path or '-' (stdin) for multi-line batch
+
+    Original line text is preserved so trailing '@ cost' survives.
+    """
+    if not items:
+        raise ValueError("no positions provided")
+
+    if len(items) == 1:
+        token = items[0]
+        if token == "-" or Path(token).is_file():
+            lines = read_batch_lines(token)
+            if not lines:
+                raise ValueError("no positions to add (empty input)")
+            return lines
+        if ";" in token:
+            parts = split_semi_separated(token)
+            if not parts:
+                raise ValueError("no positions to add")
+            return parts
+        try:
+            return [_validated_line(token)]
+        except OccError as exc:
+            raise ValueError(str(exc)) from exc
+
+    # Multiple argv tokens: either many OCCs, or one spaced human line
+    joined = " ".join(items)
+    if ";" in joined:
+        parts = split_semi_separated(joined)
+        if parts:
+            return parts
+
+    try:
+        return [_validated_line(joined)]
+    except OccError:
+        pass
+
+    lines: list[str] = []
+    for token in items:
+        try:
+            lines.append(_validated_line(token))
+        except OccError as exc:
+            raise ValueError(
+                f"could not parse {token!r} (also not a single human line: {joined!r})"
+            ) from exc
+    return lines
+
+
+def looks_like_field_add(
+    items: list[str],
+    underlying: str | None,
+    expiry: str | None,
+    strike: float | None,
+    option_type: str | None,
+) -> bool:
+    return (
+        not items
+        and underlying is not None
+        and expiry is not None
+        and strike is not None
+        and option_type is not None
+    )

optionda/batch.py

@@ -0,0 +1,237 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+
+from rich import box
+from rich.console import Console, Group
+from rich.panel import Panel
+from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn, TimeElapsedColumn
+from rich.table import Table
+from rich.text import Text
+
+from optionda.engine import freeze_iv_for_position
+from optionda.models import Position, Side
+from optionda.occ import OccError, parse_leg_line, require_entry, resolve_qty
+from optionda.store import AccountStore, StoreError
+
+
+@dataclass
+class BatchRow:
+    status: str  # ok | merge | fail
+    label: str
+    occ: str = ""
+    iv: float | None = None
+    source: str = ""
+    detail: str = ""
+
+
+@dataclass
+class BatchResult:
+    ok: int = 0
+    merged: int = 0
+    failed: int = 0
+    skipped: int = 0
+    errors: list[str] = field(default_factory=list)
+    rows: list[BatchRow] = field(default_factory=list)
+
+
+def read_batch_lines(source: str | Path) -> list[str]:
+    if source == "-":
+        import sys
+
+        text = sys.stdin.read()
+    else:
+        text = Path(source).read_text(encoding="utf-8")
+    lines: list[str] = []
+    for line in text.splitlines():
+        s = line.strip()
+        if not s or s.startswith("#"):
+            continue
+        lines.append(s)
+    return lines
+
+
+def short_path(path: Path) -> str:
+    try:
+        home = Path.home()
+        resolved = path.resolve()
+        if resolved.is_relative_to(home):
+            return "~/" + resolved.relative_to(home).as_posix()
+    except (OSError, ValueError):
+        pass
+    return str(path)
+
+
+def merge_detail(outcome) -> str:
+    pos = outcome.position
+    bits = [f"qty {outcome.previous_qty:g}→{pos.qty:g}"]
+    if (
+        outcome.previous_entry is not None
+        and pos.entry_premium is not None
+    ):
+        bits.append(
+            f"cost {outcome.previous_entry:g}→{pos.entry_premium:g}"
+        )
+    elif pos.entry_premium is not None:
+        bits.append(f"cost={pos.entry_premium:g}")
+    return " ".join(bits)
+
+
+def ok_detail(pos: Position) -> str:
+    cost = (
+        f" cost={pos.entry_premium:g}"
+        if pos.entry_premium is not None
+        else ""
+    )
+    return f"qty={pos.qty:g}{cost}"
+
+
+def render_batch_summary(result: BatchResult, *, book: Path | None = None) -> Panel:
+    table = Table(
+        box=box.SIMPLE_HEAD,
+        show_header=True,
+        header_style="bold",
+        pad_edge=False,
+        expand=True,
+        border_style="dim",
+    )
+    table.add_column("Status", width=6)
+    table.add_column("OCC", ratio=2)
+    table.add_column("IV*", justify="right", width=8)
+    table.add_column("Src", width=8)
+    table.add_column("Note", style="dim", ratio=1)
+
+    for row in result.rows:
+        if row.status == "ok":
+            st = Text("ok", style="bold green")
+            iv = f"{row.iv * 100:.1f}%" if row.iv is not None else "—"
+            note = row.detail
+        elif row.status == "merge":
+            st = Text("merge", style="bold cyan")
+            iv = f"{row.iv * 100:.1f}%" if row.iv is not None else "—"
+            note = row.detail
+        elif row.status == "skip":
+            st = Text("skip", style="bold yellow")
+            iv = "—"
+            note = row.detail
+        else:
+            st = Text("fail", style="bold red")
+            iv = "—"
+            note = row.detail
+        table.add_row(st, row.occ or row.label, iv, row.source or "—", note)
+
+    counts = Text.assemble(
+        ("ok ", "dim"),
+        (str(result.ok), "bold green"),
+        ("  merge ", "dim"),
+        (str(result.merged), "bold cyan" if result.merged else "dim"),
+        ("  fail ", "dim"),
+        (str(result.failed), "bold red" if result.failed else "dim"),
+    )
+    footer_bits: list = [counts]
+    if book is not None:
+        footer_bits.append(Text(f"book {short_path(book)}", style="dim"))
+
+    return Panel(
+        Group(table, *footer_bits),
+        title="add",
+        title_align="left",
+        border_style="cyan",
+        box=box.SQUARE,
+        padding=(0, 1),
+    )
+
+
+def add_batch(
+    store: AccountStore,
+    lines: list[str],
+    *,
+    qty: float = 1.0,
+    side: Side = "long",
+    iv: float | None = None,
+    entry: float | None = None,
+    home: Path | None = None,
+    console: Console | None = None,
+) -> BatchResult:
+    out = BatchResult()
+    con = console or Console()
+    store.require_current()
+    total = len(lines)
+
+    with Progress(
+        SpinnerColumn(style="cyan"),
+        TextColumn("[cyan]{task.description}[/cyan]"),
+        BarColumn(bar_width=28, complete_style="cyan", finished_style="green"),
+        TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+        TextColumn("•"),
+        TextColumn("{task.completed}/{task.total}"),
+        TimeElapsedColumn(),
+        console=con,
+        transient=True,  # clear bar when done — summary panel follows
+    ) as progress:
+        task = progress.add_task(f"adding 0/{total}", total=total)
+        for index, line in enumerate(lines, start=1):
+            short = line if len(line) <= 36 else line[:33] + "…"
+            progress.update(task, description=f"adding {index}/{total}  {short}")
+            try:
+                leg = parse_leg_line(line)
+                cost = require_entry(leg.entry, entry)
+                line_qty = resolve_qty(leg.qty, qty)
+                parts = leg.parts
+                draft = Position(
+                    occ_symbol=parts.occ_symbol,
+                    underlying=parts.underlying,
+                    expiry=parts.expiry,
+                    strike=parts.strike,
+                    option_type=parts.option_type,
+                    qty=line_qty,
+                    side=side,
+                    iv_frozen=iv if iv is not None else 0.01,
+                    iv_as_of=datetime.now(timezone.utc),
+                    entry_premium=cost,
+                )
+                draft = freeze_iv_for_position(draft, iv=iv, home=home)
+                outcome = store.add_position(None, draft)
+                pos = outcome.position
+                if outcome.merged:
+                    out.merged += 1
+                    out.rows.append(
+                        BatchRow(
+                            status="merge",
+                            label=line,
+                            occ=pos.occ_symbol,
+                            iv=pos.iv_frozen,
+                            source=pos.iv_source or "market",
+                            detail=merge_detail(outcome),
+                        )
+                    )
+                else:
+                    out.ok += 1
+                    out.rows.append(
+                        BatchRow(
+                            status="ok",
+                            label=line,
+                            occ=pos.occ_symbol,
+                            iv=pos.iv_frozen,
+                            source=pos.iv_source or "market",
+                            detail=ok_detail(pos),
+                        )
+                    )
+            except StoreError as exc:
+                msg = str(exc)
+                out.failed += 1
+                out.errors.append(f"{line}: {msg}")
+                out.rows.append(
+                    BatchRow(status="fail", label=line, occ=line, detail=msg)
+                )
+            except (OccError, Exception) as exc:  # noqa: BLE001
+                out.failed += 1
+                out.errors.append(f"{line}: {exc}")
+                out.rows.append(
+                    BatchRow(status="fail", label=line, occ=line, detail=str(exc))
+                )
+            progress.advance(task)
+
+    return out