kitecli 0.3.3__tar.gz → 0.5.0__tar.gz

{kitecli-0.3.3 → kitecli-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kitecli
-Version: 0.3.3
+Version: 0.5.0
 Summary: KiteCLI — Multi-account, multi-broker trading positions viewer (Zerodha + Kotak Neo)
 Author: KiteCLI Team
 License: MIT
@@ -14,6 +14,7 @@ Requires-Dist: kiteconnect>=5.0.0
 Requires-Dist: pyotp>=2.9.0
 Requires-Dist: requests>=2.31.0
 Requires-Dist: yfinance>=0.2.0
+Requires-Dist: lark>=1.1.0
 Provides-Extra: server
 Requires-Dist: fastapi>=0.110.0; extra == "server"
 Requires-Dist: uvicorn[standard]>=0.27.0; extra == "server"

{kitecli-0.3.3 → kitecli-0.5.0}/cli/api_client.py

@@ -537,6 +537,73 @@ class KCLIClient:
 
         return {"accounts": results}
 
+    def get_holdings(self, api_keys: list[str] | None = None) -> dict:
+        """Fetch stock/equity holdings for specified accounts in parallel."""
+        keys = api_keys or [a.get("api_key") for a in self._accounts if a.get("api_key")]
+
+        def fetch_one(api_key):
+            mgr = _manager_for(api_key)
+            info = mgr.get_account_info(api_key)
+            broker = getattr(mgr, "broker_name", "zerodha")
+            if not info.get("authenticated"):
+                return {
+                    "name": info.get("name", api_key),
+                    "api_key": api_key,
+                    "broker": broker,
+                    "holdings": [],
+                    "total_investment": 0.0,
+                    "total_current_value": 0.0,
+                    "total_pnl": 0.0,
+                    "total_day_change": 0.0,
+                    "status": "unauthenticated",
+                }
+            try:
+                holdings = mgr.get_holdings(api_key)
+                tot_inv = sum(h.get("investment_value", 0.0) for h in holdings)
+                tot_cur = sum(h.get("current_value", 0.0) for h in holdings)
+                tot_pnl = tot_cur - tot_inv
+                tot_day = sum(h.get("day_change", 0.0) for h in holdings)
+                return {
+                    "name": info.get("name", api_key),
+                    "api_key": api_key,
+                    "broker": broker,
+                    "holdings": holdings,
+                    "total_investment": tot_inv,
+                    "total_current_value": tot_cur,
+                    "total_pnl": tot_pnl,
+                    "total_day_change": tot_day,
+                    "status": "success",
+                }
+            except Exception as exc:
+                return {
+                    "name": info.get("name", api_key),
+                    "api_key": api_key,
+                    "broker": broker,
+                    "holdings": [],
+                    "total_investment": 0.0,
+                    "total_current_value": 0.0,
+                    "total_pnl": 0.0,
+                    "total_day_change": 0.0,
+                    "status": f"error: {exc}",
+                }
+
+        with ThreadPoolExecutor(max_workers=max(1, len(keys))) as executor:
+            results = list(executor.map(fetch_one, keys))
+
+        grand_inv = sum(a.get("total_investment", 0.0) for a in results)
+        grand_cur = sum(a.get("total_current_value", 0.0) for a in results)
+        grand_pnl = grand_cur - grand_inv
+        grand_day = sum(a.get("total_day_change", 0.0) for a in results)
+
+        return {
+            "accounts": results,
+            "grand_total_investment": grand_inv,
+            "grand_total_current_value": grand_cur,
+            "grand_total_pnl": grand_pnl,
+            "grand_total_day_change": grand_day,
+            "status": "success",
+        }
+
     def modify_order(
         self,
         api_key: str,
@@ -578,6 +645,10 @@ class KCLIClient:
         """Fetch NFO tradingsymbol → lot_size map (one-shot, cache at startup)."""
         return _kite_manager.get_nfo_lot_sizes()
 
+    def get_nfo_symbol_token_map(self) -> dict:
+        """Fetch NFO tradingsymbol → instrument_token map."""
+        return _kite_manager.get_nfo_symbol_token_map()
+
     def get_market_indices(self) -> dict:
         """Fetch live Nifty, Sensex, and India VIX."""
         return _kite_manager.get_market_indices()

{kitecli-0.3.3 → kitecli-0.5.0}/cli/base_manager.py

@@ -81,6 +81,10 @@ class BaseBrokerManager(ABC):
     def get_margins(self, account_key: str) -> dict[str, Any]:
         """Return {"net": float|None, "cash": float|None, "collateral": float|None}."""
 
+    @abstractmethod
+    def get_holdings(self, account_key: str) -> list[dict[str, Any]]:
+        """Fetch equity/stock holdings using the normalised schema."""
+
     # ── order management ──────────────────────────────────────────────────────
 
     @abstractmethod
@@ -140,6 +144,10 @@ class BaseBrokerManager(ABC):
         """
         return {}
 
+    def get_nfo_symbol_token_map(self) -> dict[str, int]:
+        """Return tradingsymbol → instrument_token map for NFO instruments. Default: empty dict."""
+        return {}
+
     def get_market_indices(self) -> dict[str, Any]:
         """Return Nifty / Sensex / India VIX snapshot. Default: not supported."""
         return {"status": "error", "message": "not supported by this broker"}

{kitecli-0.3.3 → kitecli-0.5.0}/cli/display.py

@@ -404,6 +404,337 @@ def display_status(accounts: list[dict]) -> None:
     )
 
 
+# ── Holdings Display ───────────────────────────────────────────────
+
+def _clean_instrument_name(name: str) -> str:
+    """Clean up verbose mutual fund or stock names for compact table display."""
+    import re
+    s = name.strip()
+    # Mutual fund scheme name compressions
+    s = re.sub(r"\s*-\s*DIRECT\s+PLAN\s*-\s*GROWTH(?:\s+OPTION)?", " (Dir-Gr)", s, flags=re.IGNORECASE)
+    s = re.sub(r"\s*-\s*DIRECT\s+PLAN\s*-\s*IDCW(?:\s+OPTION)?", " (Dir-IDCW)", s, flags=re.IGNORECASE)
+    s = re.sub(r"\s*-\s*DIRECT\s+PLAN", " (Dir)", s, flags=re.IGNORECASE)
+    s = re.sub(r"\s*-\s*REGULAR\s+PLAN\s*-\s*GROWTH(?:\s+OPTION)?", " (Reg-Gr)", s, flags=re.IGNORECASE)
+    s = re.sub(r"\s*-\s*REGULAR\s+PLAN", " (Reg)", s, flags=re.IGNORECASE)
+    s = re.sub(r"\s*-\s*GROWTH\s+PLAN", " (Gr)", s, flags=re.IGNORECASE)
+    s = re.sub(r"\s*-\s*GROWTH\s+OPTION", " (Gr)", s, flags=re.IGNORECASE)
+    s = re.sub(r"\s+FUND\s+OF\s+FUND", " FoF", s, flags=re.IGNORECASE)
+    s = re.sub(r"\s+INDEX\s+FUND", " Index", s, flags=re.IGNORECASE)
+    s = re.sub(r"\s+ETF\s+FUND\s+OF\s+FUND", " ETF FoF", s, flags=re.IGNORECASE)
+    return s.strip()
+
+
+def _build_holdings_summary_table(accounts_data: list[dict]) -> Table:
+    """Build a summary Table showing total holdings metrics per account."""
+    table = Table(
+        show_header=True,
+        header_style="bold #58a6ff",
+        border_style="#30363d",
+        row_styles=["", "dim"],
+        pad_edge=True,
+        expand=False,
+    )
+    table.add_column("Account", style="bold #e6edf3", no_wrap=True)
+    table.add_column("Invested", justify="right", no_wrap=True)
+    table.add_column("Current Value", justify="right", no_wrap=True)
+    table.add_column("Total P&L", justify="right", no_wrap=True)
+    table.add_column("P&L %", justify="right", no_wrap=True)
+    table.add_column("Day P&L", justify="right", no_wrap=True)
+
+    for acct in accounts_data:
+        name = acct.get("name", "Unknown")
+        status = acct.get("status", "success")
+        holdings = acct.get("holdings", [])
+        
+        if status != "success" and not holdings:
+            table.add_row(
+                name,
+                "₹0.00",
+                "₹0.00",
+                Text(f"✗ {status}", style="#f85149"),
+                "0.00%",
+                "₹0.00",
+            )
+            continue
+
+        tot_inv = float(acct.get("total_investment", 0.0))
+        tot_cur = float(acct.get("total_current_value", 0.0))
+        tot_pnl = tot_cur - tot_inv
+        tot_day = float(acct.get("total_day_change", 0.0))
+        pnl_pct = (tot_pnl / tot_inv * 100.0) if tot_inv > 0 else 0.0
+
+        pnl_color = _pnl_style(tot_pnl)
+        day_color = _pnl_style(tot_day)
+
+        table.add_row(
+            name,
+            _format_currency(tot_inv),
+            _format_currency(tot_cur),
+            Text(_format_currency(tot_pnl), style=f"bold {pnl_color}"),
+            Text(_format_pnl_pct(pnl_pct), style=f"bold {pnl_color}"),
+            Text(_format_currency(tot_day), style=day_color),
+        )
+
+    # Total Row at the bottom of the table
+    if accounts_data:
+        grand_inv = sum(float(a.get("total_investment", 0.0)) for a in accounts_data)
+        grand_cur = sum(float(a.get("total_current_value", 0.0)) for a in accounts_data)
+        grand_pnl = grand_cur - grand_inv
+        grand_day = sum(float(a.get("total_day_change", 0.0)) for a in accounts_data)
+        grand_pnl_pct = (grand_pnl / grand_inv * 100.0) if grand_inv > 0 else 0.0
+
+        pnl_color = _pnl_style(grand_pnl)
+        day_color = _pnl_style(grand_day)
+
+        table.add_section()
+        table.add_row(
+            Text("Total", style="bold #e6edf3"),
+            Text(_format_currency(grand_inv), style="bold #e6edf3"),
+            Text(_format_currency(grand_cur), style="bold #e6edf3"),
+            Text(_format_currency(grand_pnl), style=f"bold {pnl_color}"),
+            Text(_format_pnl_pct(grand_pnl_pct), style=f"bold {pnl_color}"),
+            Text(_format_currency(grand_day), style=f"bold {day_color}"),
+        )
+
+    return table
+
+
+def _build_account_deep_holdings_table(holdings: list[dict]) -> Table:
+    """Build a detailed constituents Table for an account's holdings."""
+    table = Table(
+        show_header=True,
+        header_style="bold #58a6ff",
+        border_style="#30363d",
+        row_styles=["", "dim"],
+        pad_edge=True,
+        expand=False,
+    )
+    table.add_column("Symbol", style="bold #e6edf3", max_width=32, no_wrap=True, overflow="ellipsis")
+    table.add_column("Qty", justify="right", style="#79c0ff", no_wrap=True)
+    table.add_column("Avg", justify="right", no_wrap=True)
+    table.add_column("LTP", justify="right", no_wrap=True)
+    table.add_column("Invested", justify="right", no_wrap=True)
+    table.add_column("Current", justify="right", no_wrap=True)
+    table.add_column("Total P&L", justify="right", no_wrap=True)
+    table.add_column("P&L %", justify="right", no_wrap=True)
+
+    # Sort holdings alphabetically by tradingsymbol
+    sorted_holdings = sorted(holdings, key=lambda h: str(h.get("tradingsymbol", "")))
+
+    for h in sorted_holdings:
+        raw_sym = str(h.get("tradingsymbol", "?"))
+        sym = _clean_instrument_name(raw_sym)
+        is_mf = (h.get("exchange") == "MF" or h.get("instrument_type") == "MF")
+        sym_style = "italic #79c0ff" if is_mf else "bold #e6edf3"
+        
+        qty_val = float(h.get("quantity", 0))
+        qty_fmt = f"{int(qty_val)}" if qty_val.is_integer() else f"{qty_val:,.2f}"
+
+        avg = float(h.get("average_price", 0.0))
+        ltp = float(h.get("last_price", avg))
+        inv = float(h.get("investment_value", qty_val * avg))
+        cur = float(h.get("current_value", qty_val * ltp))
+        pnl = cur - inv
+        pnl_pct = (pnl / inv * 100.0) if inv > 0 else 0.0
+
+        pnl_color = _pnl_style(pnl)
+
+        table.add_row(
+            Text(sym, style=sym_style),
+            qty_fmt,
+            f"{avg:,.2f}",
+            f"{ltp:,.2f}",
+            _format_currency(inv),
+            _format_currency(cur),
+            Text(_format_currency(pnl), style=f"bold {pnl_color}"),
+            Text(_format_pnl_pct(pnl_pct), style=f"bold {pnl_color}"),
+        )
+
+    # Total Row for multiple constituents
+    if len(sorted_holdings) > 1:
+        tot_qty = sum(float(h.get("quantity", 0)) for h in sorted_holdings)
+        tot_qty_str = f"{int(tot_qty)}" if tot_qty.is_integer() else f"{tot_qty:,.2f}"
+        tot_inv = sum(float(h.get("investment_value", float(h.get("quantity", 0)) * float(h.get("average_price", 0.0)))) for h in sorted_holdings)
+        tot_cur = sum(float(h.get("current_value", float(h.get("quantity", 0)) * float(h.get("last_price", 0.0)))) for h in sorted_holdings)
+        tot_pnl = tot_cur - tot_inv
+        tot_pnl_pct = (tot_pnl / tot_inv * 100.0) if tot_inv > 0 else 0.0
+
+        pnl_color = _pnl_style(tot_pnl)
+
+        table.add_section()
+        table.add_row(
+            Text("Total", style="bold #e6edf3"),
+            Text(tot_qty_str, style="bold #79c0ff"),
+            Text("-", style="#8b949e", justify="right"),
+            Text("-", style="#8b949e", justify="right"),
+            Text(_format_currency(tot_inv), style="bold #e6edf3"),
+            Text(_format_currency(tot_cur), style="bold #e6edf3"),
+            Text(_format_currency(tot_pnl), style=f"bold {pnl_color}"),
+            Text(_format_pnl_pct(tot_pnl_pct), style=f"bold {pnl_color}"),
+        )
+
+    return table
+
+
+def display_holdings(holdings_data: dict, deep: bool = False, target_account: Optional[str] = None) -> None:
+    """Print a Rich table of stock holdings across accounts.
+
+    Args:
+        holdings_data: Dict returned by client.get_holdings().
+        deep: If True, show full constituent stock breakdowns.
+        target_account: Optional account name or ID to filter single-account deep-dive.
+    """
+    accounts = holdings_data.get("accounts", [])
+    if not accounts:
+        display_info("No holdings data available.")
+        return
+
+    # Filter by account if requested
+    if target_account:
+        target_norm = target_account.strip().lower()
+        if target_norm.isdigit():
+            idx = int(target_norm) - 1
+            if 0 <= idx < len(accounts):
+                accounts = [accounts[idx]]
+            else:
+                display_error(f"Invalid account index: {target_account}")
+                return
+        else:
+            accounts = [a for a in accounts if a.get("name", "").lower() == target_norm or a.get("api_key", "").lower() == target_norm]
+            if not accounts:
+                display_error(f"Account '{target_account}' not found.")
+                return
+        deep = True  # Single account drill-down defaults to deep view
+
+    if not deep:
+        # Summary View
+        table = _build_holdings_summary_table(accounts)
+        console.print(table)
+        console.print()
+    else:
+        # Deep View: Per-account constituent tables
+        for acct in accounts:
+            name = acct.get("name", "Unknown")
+            broker = str(acct.get("broker", "zerodha")).title()
+            holdings = acct.get("holdings", [])
+            tot_cur = float(acct.get("total_current_value", 0.0))
+            tot_inv = float(acct.get("total_investment", 0.0))
+            tot_pnl = tot_cur - tot_inv
+            pnl_pct = (tot_pnl / tot_inv * 100.0) if tot_inv > 0 else 0.0
+            pnl_color = _pnl_style(tot_pnl)
+
+            header_text = Text.assemble(
+                (f" {name} ({broker}) ", "bold #e6edf3"),
+                (" │ ", "#8b949e"),
+                ("Invested: ", "#8b949e"),
+                (f"{_format_currency(tot_inv)} ", "bold"),
+                (" │ ", "#8b949e"),
+                ("Current: ", "#8b949e"),
+                (f"{_format_currency(tot_cur)} ", "bold"),
+                (" │ ", "#8b949e"),
+                ("P&L: ", "bold"),
+                (f"{_format_currency(tot_pnl)} ({_format_pnl_pct(pnl_pct)})", f"bold {pnl_color}"),
+            )
+
+            if not holdings:
+                panel = Panel(
+                    Text("  No stock holdings in this account.", style="#8b949e italic"),
+                    title=header_text,
+                    border_style="#30363d",
+                    padding=(1, 2),
+                )
+            else:
+                table = _build_account_deep_holdings_table(holdings)
+                panel = Panel(
+                    table,
+                    title=header_text,
+                    border_style=pnl_color,
+                    padding=(0, 1),
+                )
+            console.print(panel)
+            console.print()
+
+
+def render_holdings_to_string(
+    holdings_data: dict,
+    width: int = 100,
+    deep: bool = False,
+    target_account: Optional[str] = None
+) -> str:
+    """Render holdings to an ANSI string for the live session TUI."""
+    from io import StringIO
+    from rich.console import Console
+
+    string_io = StringIO()
+    capture_console = Console(
+        file=string_io,
+        width=max(width, 100),
+        force_terminal=True,
+        color_system="truecolor",
+    )
+    accounts = holdings_data.get("accounts", [])
+    if not accounts:
+        return "No holdings data available."
+
+    if target_account:
+        target_norm = target_account.strip().lower()
+        if target_norm.isdigit():
+            idx = int(target_norm) - 1
+            if 0 <= idx < len(accounts):
+                accounts = [accounts[idx]]
+        else:
+            filtered = [a for a in accounts if a.get("name", "").lower() == target_norm or a.get("api_key", "").lower() == target_norm]
+            if filtered:
+                accounts = filtered
+        deep = True
+
+    if not deep:
+        table = _build_holdings_summary_table(accounts)
+        capture_console.print(table)
+    else:
+        for acct in accounts:
+            name = acct.get("name", "Unknown")
+            broker = str(acct.get("broker", "zerodha")).title()
+            holdings = acct.get("holdings", [])
+            tot_cur = float(acct.get("total_current_value", 0.0))
+            tot_inv = float(acct.get("total_investment", 0.0))
+            tot_pnl = tot_cur - tot_inv
+            pnl_pct = (tot_pnl / tot_inv * 100.0) if tot_inv > 0 else 0.0
+            pnl_color = _pnl_style(tot_pnl)
+
+            header_text = Text.assemble(
+                (f" {name} ({broker}) ", "bold #e6edf3"),
+                (" │ ", "#8b949e"),
+                ("Invested: ", "#8b949e"),
+                (f"{_format_currency(tot_inv)} ", "bold"),
+                (" │ ", "#8b949e"),
+                ("Current: ", "#8b949e"),
+                (f"{_format_currency(tot_cur)} ", "bold"),
+                (" │ ", "#8b949e"),
+                ("P&L: ", "bold"),
+                (f"{_format_currency(tot_pnl)} ({_format_pnl_pct(pnl_pct)})", f"bold {pnl_color}"),
+            )
+
+            if not holdings:
+                panel = Panel(
+                    Text("  No stock holdings in this account.", style="#8b949e italic"),
+                    title=header_text,
+                    border_style="#30363d",
+                    padding=(0, 1),
+                )
+            else:
+                table = _build_account_deep_holdings_table(holdings)
+                panel = Panel(
+                    table,
+                    title=header_text,
+                    border_style=pnl_color,
+                    padding=(0, 1),
+                )
+            capture_console.print(panel)
+
+    return string_io.getvalue()
+
+
 # ── Simple messages ────────────────────────────────────────────────
 
 def display_error(message: str) -> None:

{kitecli-0.3.3 → kitecli-0.5.0}/cli/executor.py

@@ -4,7 +4,8 @@ from cli.parser import (
     AccountSelectCommand, PlaceOrderCommand, ExitCommand,
     StatusCommand, PositionsCommand, OrdersCommand,
     CancelOrderCommand, ModifyOrderCommand, MarketDepthCommand,
-    ConditionalOrderCommand, CancelConditionalOrderCommand, ConditionalOrdersViewCommand
+    ConditionalOrderCommand, CancelConditionalOrderCommand, ConditionalOrdersViewCommand,
+    CancelScheduledOrderCommand, ScheduledOrdersViewCommand
 )
 
 class ExecutionContext:
@@ -450,4 +451,18 @@ async def execute_command(cmd: Any, context: ExecutionContext) -> dict:
             "message": "Conditional orders viewer is active in live TUI dashboard ('kcli live')."
         }
 
+    # 13. Cancel Scheduled Order Command
+    elif isinstance(cmd, CancelScheduledOrderCommand):
+        return {
+            "status": "executed",
+            "message": f"Cancelled scheduled orders targeting '{cmd.target}'."
+        }
+
+    # 14. Scheduled Orders View Command
+    elif isinstance(cmd, ScheduledOrdersViewCommand):
+        return {
+            "status": "executed",
+            "message": "Scheduled orders viewer is active in live TUI dashboard ('kcli live')."
+        }
+
     raise TypeError(f"Execution not implemented for command type '{type(cmd)}'.")