kitecli 0.3.3__tar.gz → 0.4.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kitecli
-Version: 0.3.3
+Version: 0.4.0
 Summary: KiteCLI — Multi-account, multi-broker trading positions viewer (Zerodha + Kotak Neo)
 Author: KiteCLI Team
 License: MIT

{kitecli-0.3.3 → kitecli-0.4.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,

{kitecli-0.3.3 → kitecli-0.4.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

{kitecli-0.3.3 → kitecli-0.4.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.4.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)}'.")

{kitecli-0.3.3 → kitecli-0.4.0}/cli/kite_manager.py

@@ -1009,6 +1009,109 @@ class KiteAccountManager(BaseBrokerManager):
             logger.warning("get_margins failed for api_key=%s…: %s", api_key[:8], exc)
             return {"net": None, "cash": None, "collateral": None}
 
+    def get_holdings(self, api_key: str) -> list[dict[str, Any]]:
+        """Fetch stock/equity and mutual fund holdings for an account using normalised schema.
+
+        Normalised schema:
+            tradingsymbol, exchange, isin, quantity, t1_quantity, collateral_quantity,
+            average_price, last_price, close_price, pnl, pnl_pct,
+            day_change, day_change_pct, investment_value, current_value, instrument_type
+        """
+        kite = self._clients.get(api_key)
+        if not kite or not self.is_authenticated(api_key):
+            return []
+        
+        result = []
+
+        # 1. Fetch equity/CNC holdings (including free demat, T1, and pledged/collateral)
+        try:
+            raw_holdings = kite.holdings()
+            for h in raw_holdings:
+                qty = float(h.get("quantity") or 0.0)
+                t1_qty = float(h.get("t1_quantity") or 0.0)
+                collateral_qty = float(h.get("collateral_quantity") or 0.0)
+                total_qty = qty + t1_qty + collateral_qty
+                if total_qty == 0:
+                    continue
+                avg_price = float(h.get("average_price") or 0.0)
+                ltp = float(h.get("last_price") or avg_price)
+                close_price = float(h.get("close_price") or ltp)
+                
+                investment_val = total_qty * avg_price
+                current_val = total_qty * ltp
+                pnl = current_val - investment_val
+                pnl_pct = (pnl / investment_val * 100.0) if investment_val > 0 else 0.0
+                
+                # Day change
+                day_change = (ltp - close_price) * total_qty
+                day_change_pct = ((ltp - close_price) / close_price * 100.0) if close_price > 0 else float(h.get("day_change_percentage") or 0.0)
+                
+                result.append({
+                    "tradingsymbol": str(h.get("tradingsymbol") or ""),
+                    "exchange": str(h.get("exchange") or "NSE"),
+                    "isin": str(h.get("isin") or ""),
+                    "quantity": int(total_qty) if total_qty.is_integer() else total_qty,
+                    "t1_quantity": int(t1_qty) if t1_qty.is_integer() else t1_qty,
+                    "collateral_quantity": int(collateral_qty) if collateral_qty.is_integer() else collateral_qty,
+                    "average_price": avg_price,
+                    "last_price": ltp,
+                    "close_price": close_price,
+                    "pnl": pnl,
+                    "pnl_pct": pnl_pct,
+                    "day_change": day_change,
+                    "day_change_pct": day_change_pct,
+                    "investment_value": investment_val,
+                    "current_value": current_val,
+                    "instrument_token": h.get("instrument_token"),
+                    "instrument_type": "EQ",
+                })
+        except Exception as exc:
+            logger.warning("kite.holdings failed for api_key=%s…: %s", api_key[:8], exc)
+
+        # 2. Fetch Mutual Fund holdings (Coin / BSE StAR MF)
+        try:
+            if hasattr(kite, "mf_holdings"):
+                raw_mf_holdings = kite.mf_holdings()
+                for mf in raw_mf_holdings:
+                    qty = float(mf.get("quantity") or 0.0)
+                    if qty == 0:
+                        continue
+                    avg_nav = float(mf.get("average_price") or 0.0)
+                    last_nav = float(mf.get("last_price") or avg_nav)
+                    fund_name = str(mf.get("fund") or mf.get("tradingsymbol") or "Mutual Fund")
+                    isin = str(mf.get("isin") or "")
+                    
+                    investment_val = qty * avg_nav
+                    current_val = qty * last_nav
+                    pnl = current_val - investment_val
+                    pnl_pct = (pnl / investment_val * 100.0) if investment_val > 0 else 0.0
+                    day_change = float(mf.get("day_change") or 0.0)
+                    day_change_pct = float(mf.get("day_change_percentage") or 0.0)
+
+                    result.append({
+                        "tradingsymbol": fund_name,
+                        "exchange": "MF",
+                        "isin": isin,
+                        "quantity": int(qty) if qty.is_integer() else qty,
+                        "t1_quantity": 0,
+                        "collateral_quantity": 0,
+                        "average_price": avg_nav,
+                        "last_price": last_nav,
+                        "close_price": last_nav,
+                        "pnl": pnl,
+                        "pnl_pct": pnl_pct,
+                        "day_change": day_change,
+                        "day_change_pct": day_change_pct,
+                        "investment_value": investment_val,
+                        "current_value": current_val,
+                        "instrument_token": None,
+                        "instrument_type": "MF",
+                    })
+        except Exception as exc:
+            logger.debug("kite.mf_holdings failed or not supported for api_key=%s…: %s", api_key[:8], exc)
+
+        return result
+
     def get_nfo_lot_sizes(self) -> dict[str, int]:
         """Return the cached NFO tradingsymbol → lot_size map.