kitecli 0.2.9__tar.gz → 0.3.1__tar.gz

{kitecli-0.2.9 → kitecli-0.3.1}/PKG-INFO

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

kitecli-0.3.1/cli/__init__.py

@@ -0,0 +1,2 @@
+# KiteCLI - Kite Connect CLI
+

{kitecli-0.2.9 → kitecli-0.3.1}/cli/api_client.py

@@ -261,6 +261,30 @@ class KCLIClient:
         except Exception as exc:
             raise KCLIClientError(str(exc)) from exc
 
+    def get_order_margin(
+        self,
+        api_key: str,
+        tradingsymbol: str,
+        transaction_type: str,
+        quantity: int,
+        price: float | None = None,
+        product: str = "NRML",
+        exchange: str = "NFO",
+        order_type: str = "LIMIT",
+    ) -> dict:
+        """Calculate margin required for a proposed order on a specific account."""
+        mgr = _manager_for(api_key)
+        return mgr.get_order_margin(
+            account_key=api_key,
+            tradingsymbol=tradingsymbol,
+            transaction_type=transaction_type,
+            quantity=quantity,
+            price=price,
+            product=product,
+            exchange=exchange,
+            order_type=order_type,
+        )
+
     def get_positions(self, api_keys: list[str]) -> dict:
         """Fetch open positions for the given accounts in parallel."""
         keys = api_keys or [a.get("api_key") for a in self._accounts if a.get("api_key")]

{kitecli-0.2.9 → kitecli-0.3.1}/cli/base_manager.py

@@ -143,3 +143,17 @@ class BaseBrokerManager(ABC):
     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"}
+
+    def get_order_margin(
+        self,
+        account_key: str,
+        tradingsymbol: str,
+        transaction_type: str,
+        quantity: int,
+        price: float | None = None,
+        product: str = "NRML",
+        exchange: str = "NFO",
+        order_type: str = "LIMIT",
+    ) -> dict[str, Any]:
+        """Calculate margin required for a proposed order. Default: fallback estimation."""
+        return {"status": "error", "message": "not supported by this broker"}

kitecli-0.3.1/cli/charges.py

@@ -0,0 +1,92 @@
+"""Zerodha & Statutory Charges Calculation Engine for Indian F&O & Equity Trades.
+
+Official Rates from https://zerodha.com/charges/#charges-explained:
+- Brokerage: Flat ₹20 per executed order (or 0.03% whichever is lower).
+- STT/CTT: 0.15% on sell side (on premium value).
+- Transaction charges: NSE/NFO Options = 0.03553% (on premium), BSE/BFO Options = 0.0325% (on premium).
+- GST: 18% on (brokerage + SEBI charges + transaction charges).
+- SEBI charges: ₹10 / crore (0.0001%).
+- Stamp charges: 0.003% or ₹300 / crore on buy side.
+- IPFT fee: ₹50 / crore (0.0005%).
+"""
+
+from typing import Any
+
+
+def calculate_option_charges(
+    buy_price: float,
+    sell_price: float,
+    qty: int,
+    buy_orders_count: int = 1,
+    sell_orders_count: int = 1,
+    exchange: str = "NSE",
+) -> dict[str, float]:
+    """Calculate exact statutory charges and taxes for an F&O option contract trade per Zerodha official rates.
+
+    Args:
+        buy_price: Average buy price of matched legs.
+        sell_price: Average sell price of matched legs.
+        qty: Matched quantity.
+        buy_orders_count: Number of buy orders executed.
+        sell_orders_count: Number of sell orders executed.
+        exchange: Exchange name ('NSE', 'NFO', 'BSE', 'BFO').
+
+    Returns:
+        Dictionary containing breakdown of brokerage, STT, exchange fees, SEBI fees,
+        GST, stamp duty, IPFT, total charges, and net P&L.
+    """
+    buy_val = max(0.0, buy_price * qty)
+    sell_val = max(0.0, sell_price * qty)
+    total_val = buy_val + sell_val
+
+    exch_str = str(exchange or "NSE").upper()
+    is_nse = exch_str in ["NSE", "NFO"]
+
+    # 1. Brokerage: Flat ₹20 per executed order
+    brokerage = float((buy_orders_count + sell_orders_count) * 20.0)
+
+    # 2. STT: 0.15% on Sell side premium (Zerodha official rate)
+    stt = round(sell_val * 0.0015, 2)
+
+    # 3. Transaction charges: NSE/NFO Options = 0.03553% on premium, BSE/BFO Options = 0.0325% on premium
+    exch_rate = 0.0003553 if is_nse else 0.000325
+    exch_fee = round(total_val * exch_rate, 2)
+
+    # 4. SEBI turnover fee: ₹10 / crore (0.0001%)
+    sebi_fee = round(total_val * 0.000001, 2)
+
+    # 5. IPFT fee: ₹50 / crore (0.000005%) for NSE/NFO
+    ipft_fee = round(total_val * 0.000005, 2) if is_nse else 0.0
+
+    # 6. GST: 18% on (Brokerage + Exchange Fee + SEBI Fee)
+    gst = round((brokerage + exch_fee + sebi_fee) * 0.18, 2)
+
+    # 7. Stamp duty: 0.003% (₹300/crore) on Buy side premium
+    stamp_duty = round(buy_val * 0.00003, 2)
+
+    total_charges = round(brokerage + stt + exch_fee + sebi_fee + ipft_fee + gst + stamp_duty, 2)
+
+    return {
+        "brokerage": brokerage,
+        "stt": stt,
+        "exch_fee": exch_fee,
+        "sebi_fee": sebi_fee,
+        "ipft_fee": ipft_fee,
+        "gst": gst,
+        "stamp_duty": stamp_duty,
+        "total_charges": total_charges,
+    }
+
+
+def fetch_broker_charges(client: Any, order_params_list: list[dict[str, Any]]) -> float | None:
+    """Fetch official charges from Zerodha API if available."""
+    try:
+        if hasattr(client, "get_order_charges"):
+            resp = client.get_order_charges(order_params_list)
+            if isinstance(resp, list):
+                return sum(float(item.get("total", 0.0)) for item in resp)
+            elif isinstance(resp, dict):
+                return float(resp.get("total", 0.0))
+    except Exception:
+        pass
+    return None

{kitecli-0.2.9 → kitecli-0.3.1}/cli/config.py

@@ -21,6 +21,7 @@ sessions_lock = threading.RLock()
 logger = logging.getLogger(__name__)
 
 DEFAULT_CONFIG = {
+    "record_executed_order_context": False,
     "accounts": [
         {
             # --- Zerodha account (default) ---

{kitecli-0.2.9 → kitecli-0.3.1}/cli/executor.py

@@ -247,6 +247,19 @@ async def execute_command(cmd: Any, context: ExecutionContext) -> dict:
             "message": "\n".join(output_lines)
         }
 
+    # 5.5 Status Command
+    elif isinstance(cmd, StatusCommand):
+        res = context.client.get_status()
+        output_lines = ["🔌 Account Connection & Health Status:"]
+        for acct in res.get("accounts", []):
+            auth_icon = "🟢 Active" if acct.get("authenticated") else "🔴 Inactive"
+            broker_name = acct.get("broker", "Zerodha").title()
+            output_lines.append(f"  • {acct.get('name', 'Account')} ({broker_name}): {auth_icon}")
+        return {
+            "status": "executed",
+            "message": "\n".join(output_lines)
+        }
+
     # 6. Orders Command
     elif isinstance(cmd, OrdersCommand):
         api_keys = [context.selected_account_key] if context.selected_account_key != "ALL" else None

kitecli-0.3.1/cli/greeks.py

@@ -0,0 +1,160 @@
+import calendar
+import math
+import re
+from datetime import date, datetime, timedelta
+from typing import Any, Dict, Optional
+
+MONTH_MAP = {
+    "JAN": 1, "FEB": 2, "MAR": 3, "APR": 4, "MAY": 5, "JUN": 6,
+    "JUL": 7, "AUG": 8, "SEP": 9, "OCT": 10, "NOV": 11, "DEC": 12,
+}
+MONTH_CODE_MAP = {
+    "1": 1, "2": 2, "3": 3, "4": 4, "5": 5, "6": 6,
+    "7": 7, "8": 8, "9": 9, "O": 10, "N": 11, "D": 12,
+}
+
+# Standard Normal Cumulative Distribution Function
+def _norm_cdf(x: float) -> float:
+    return (1.0 + math.erf(x / math.sqrt(2.0))) / 2.0
+
+
+# Standard Normal Probability Density Function
+def _norm_pdf(x: float) -> float:
+    return math.exp(-0.5 * x * x) / math.sqrt(2.0 * math.pi)
+
+
+def parse_nfo_symbol(symbol: str) -> Optional[Dict[str, Any]]:
+    """Parse NFO option tradingsymbol into strike, option_type, and estimated expiry date."""
+    symbol = symbol.strip().upper()
+    if not (symbol.endswith("CE") or symbol.endswith("PE")):
+        return None
+
+    opt_type = "PE" if symbol.endswith("PE") else "CE"
+    core = symbol[:-2]
+
+    # Pattern A: Monthly (e.g. NIFTY26JUL22500 or BANKNIFTY26AUG50000)
+    m_monthly = re.match(r"^([A-Z]+)(\d{2})([A-Z]{3})(\d+(?:\.\d+)?)$", core)
+    if m_monthly:
+        underlying, yy, mon_str, strike_str = m_monthly.groups()
+        year = 2000 + int(yy)
+        month = MONTH_MAP.get(mon_str, date.today().month)
+        strike = float(strike_str)
+        cal = calendar.monthcalendar(year, month)
+        thursdays = [week[calendar.THURSDAY] for week in cal if week[calendar.THURSDAY] != 0]
+        expiry_day = thursdays[-1] if thursdays else 28
+        exp_date = date(year, month, expiry_day)
+        return {"underlying": underlying, "option_type": opt_type, "strike": strike, "expiry_date": exp_date}
+
+    # Pattern B: Weekly (e.g. NIFTY2672522500 -> YY=26, M=7, DD=25, STRIKE=22500)
+    m_weekly = re.match(r"^([A-Z]+)(\d{2})([1-9OND])(\d{2})(\d+(?:\.\d+)?)$", core)
+    if m_weekly:
+        underlying, yy, m_code, dd_str, strike_str = m_weekly.groups()
+        year = 2000 + int(yy)
+        month = MONTH_CODE_MAP.get(m_code, date.today().month)
+        day = int(dd_str)
+        strike = float(strike_str)
+        try:
+            exp_date = date(year, month, day)
+        except ValueError:
+            exp_date = date.today() + timedelta(days=7)
+        return {"underlying": underlying, "option_type": opt_type, "strike": strike, "expiry_date": exp_date}
+
+    # Fallback pattern if non-standard string:
+    nums = re.findall(r"\d+", core)
+    if nums:
+        strike = float(nums[-1])
+        exp_date = date.today() + timedelta(days=7)
+        return {"underlying": "NIFTY", "option_type": opt_type, "strike": strike, "expiry_date": exp_date}
+
+    return None
+
+
+def calculate_greeks_for_symbol(symbol: str, spot_price: float, vix_pct: float = 15.0) -> Dict[str, Optional[float]]:
+    """Helper to calculate Option Greeks directly from a tradingsymbol."""
+    parsed = parse_nfo_symbol(symbol)
+    if not parsed:
+        return {"delta": None, "gamma": None, "theta": None, "vega": None, "iv": None}
+
+    return calculate_greeks(
+        spot_price=spot_price,
+        strike_price=parsed["strike"],
+        expiry_date=parsed["expiry_date"],
+        option_type=parsed["option_type"],
+        vix_pct=vix_pct,
+    )
+
+
+def calculate_greeks(
+    spot_price: float,
+    strike_price: float,
+    expiry_date: str | datetime | date,
+    option_type: str,
+    vix_pct: float = 15.0,
+    risk_free_rate: float = 0.07,
+) -> Dict[str, Optional[float]]:
+    """Calculate Black-Scholes Option Greeks.
+
+    Args:
+        spot_price: Current spot price of underlying index/stock (e.g. 24500.0)
+        strike_price: Strike price of option (e.g. 24500.0)
+        expiry_date: Expiry date string (YYYY-MM-DD), date, or datetime object
+        option_type: 'CE' / 'CALL' or 'PE' / 'PUT'
+        vix_pct: Volatility percentage (e.g. 15.2 for 15.2% India VIX)
+        risk_free_rate: Annual risk-free interest rate (default 7% = 0.07)
+
+    Returns:
+        Dict containing delta, gamma, theta, vega, and iv.
+    """
+    if spot_price <= 0 or strike_price <= 0:
+        return {"delta": None, "gamma": None, "theta": None, "vega": None, "iv": None}
+
+    # Calculate time to expiry in years
+    if isinstance(expiry_date, str):
+        try:
+            exp_dt = datetime.strptime(expiry_date, "%Y-%m-%d")
+        except ValueError:
+            exp_dt = datetime.now() + timedelta(days=7)
+    elif isinstance(expiry_date, date) and not isinstance(expiry_date, datetime):
+        exp_dt = datetime.combine(expiry_date, datetime.min.time())
+    else:
+        exp_dt = expiry_date
+
+    now = datetime.now()
+    days_to_exp = max((exp_dt - now).total_seconds() / 86400.0, 0.25)
+    T = days_to_exp / 365.0
+    sigma = max(vix_pct / 100.0, 0.01)
+
+    # Black-Scholes d1 and d2 calculations
+    d1 = (math.log(spot_price / strike_price) + (risk_free_rate + 0.5 * sigma**2) * T) / (sigma * math.sqrt(T))
+    d2 = d1 - sigma * math.sqrt(T)
+
+    opt_type_upper = option_type.upper()
+    is_call = "CE" in opt_type_upper or "CALL" in opt_type_upper
+
+    # 1. Delta
+    if is_call:
+        delta = _norm_cdf(d1)
+    else:
+        delta = _norm_cdf(d1) - 1.0
+
+    # 2. Gamma
+    gamma = _norm_pdf(d1) / (spot_price * sigma * math.sqrt(T))
+
+    # 3. Theta (daily decay)
+    term1 = -(spot_price * _norm_pdf(d1) * sigma) / (2.0 * math.sqrt(T))
+    if is_call:
+        term2 = -risk_free_rate * strike_price * math.exp(-risk_free_rate * T) * _norm_cdf(d2)
+    else:
+        term2 = risk_free_rate * strike_price * math.exp(-risk_free_rate * T) * _norm_cdf(-d2)
+    theta = (term1 + term2) / 365.0
+
+    # 4. Vega (per 1% change in volatility)
+    vega = (spot_price * math.sqrt(T) * _norm_pdf(d1)) / 100.0
+
+    return {
+        "delta": round(delta, 4),
+        "gamma": round(gamma, 6),
+        "theta": round(theta, 2),
+        "vega": round(vega, 2),
+        "iv": round(vix_pct, 2),
+    }

kitecli-0.3.1/cli/indicators.py

@@ -0,0 +1,205 @@
+"""
+Technical indicators and daily Nifty candle cache manager for KiteCLI.
+
+Manages ~/.kcli/nifty_daily.json and calculates Daily EMA-9, SMA-20, SMA-50, and RSI-14.
+"""
+
+import json
+import logging
+from datetime import date, datetime, timedelta
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+
+logger = logging.getLogger("kitecli.indicators")
+
+CACHE_PATH = Path.home() / ".kcli" / "nifty_daily.json"
+
+
+def get_cached_daily_closes() -> tuple[Optional[str], List[float]]:
+    """Read cached daily close prices from ~/.kcli/nifty_daily.json.
+
+    Returns:
+        (last_updated_date, daily_closes_list)
+    """
+    if not CACHE_PATH.exists():
+        return None, []
+
+    try:
+        with open(CACHE_PATH, "r", encoding="utf-8") as f:
+            data = json.load(f)
+            last_date = data.get("last_updated_date")
+            closes = data.get("daily_closes", [])
+            return last_date, closes
+    except Exception as exc:
+        logger.warning("Failed to read nifty_daily.json cache: %s", exc)
+        return None, []
+
+
+def save_cached_daily_closes(daily_closes: List[float]) -> None:
+    """Save daily close prices to ~/.kcli/nifty_daily.json with today's date."""
+    CACHE_PATH.parent.mkdir(parents=True, exist_ok=True)
+    today_str = date.today().isoformat()
+    try:
+        with open(CACHE_PATH, "w", encoding="utf-8") as f:
+            json.dump({
+                "last_updated_date": today_str,
+                "daily_closes": daily_closes,
+            }, f, indent=2)
+        logger.info("Saved %d daily closes to %s for date %s", len(daily_closes), CACHE_PATH, today_str)
+    except Exception as exc:
+        logger.error("Failed to save nifty_daily.json cache: %s", exc)
+
+
+def fetch_or_get_daily_closes(client: Any) -> List[float]:
+    """Fetch 100 daily closing prices from Zerodha if missing or outdated, else return cached values."""
+    today_str = date.today().isoformat()
+    last_date, closes = get_cached_daily_closes()
+
+    if last_date == today_str and len(closes) >= 20:
+        logger.debug("Using cached daily closes for date %s (len=%d)", today_str, len(closes))
+        return closes
+
+    # First order of the day: fetch 100 daily candles from Zerodha REST API
+    logger.info("First completed order of the day (%s): fetching Nifty daily candles from Zerodha...", today_str)
+    try:
+        # NIFTY 50 instrument token = 256265
+        token = 256265
+        to_date = date.today()
+        from_date = to_date - timedelta(days=365)
+
+        # Retrieve a valid authenticated Zerodha client instance
+        kite = None
+        if hasattr(client, "_account_manager_map"):
+            for key, mgr in getattr(client, "_account_manager_map", {}).items():
+                if hasattr(mgr, "_clients") and key in mgr._clients:
+                    kite = mgr._clients[key]
+                    break
+        elif hasattr(client, "_clients"):
+            for key, client_inst in getattr(client, "_clients", {}).items():
+                kite = client_inst
+                break
+
+        if not kite:
+            try:
+                from cli.api_client import _account_manager_map, _kite_manager
+                for key, mgr in _account_manager_map.items():
+                    if getattr(mgr, "broker_name", "") == "zerodha":
+                        if hasattr(mgr, "_clients") and key in mgr._clients and mgr.is_authenticated(key):
+                            kite = mgr._clients[key]
+                            break
+                if not kite:
+                    for key, client_inst in getattr(_kite_manager, "_clients", {}).items():
+                        if _kite_manager.is_authenticated(key):
+                            kite = client_inst
+                            break
+            except Exception as exc:
+                logger.warning("Failed to locate Zerodha client: %s", exc)
+
+        if not kite:
+            logger.warning("No authenticated Zerodha client available to fetch daily candles.")
+            return closes
+
+        records = kite.historical_data(
+            instrument_token=token,
+            from_date=from_date.strftime("%Y-%m-%d"),
+            to_date=to_date.strftime("%Y-%m-%d"),
+            interval="day",
+        )
+        if records:
+            fetched_closes = [float(r["close"]) for r in records][-200:]
+            if fetched_closes:
+                save_cached_daily_closes(fetched_closes)
+                return fetched_closes
+    except Exception as exc:
+        logger.error("Failed to fetch Nifty daily historical candles: %s", exc)
+
+    return closes
+
+
+def calculate_daily_indicators(
+    client: Any, live_nifty_spot: float
+) -> Dict[str, Optional[float]]:
+    """Compute Daily EMA-9, SMA-20, SMA-50, SMA-200, RSI-14, MACD, Bollinger Bands, Distance %, and Returns."""
+    empty_res = {
+        "nifty_ema_9": None, "nifty_sma_20": None, "nifty_sma_50": None, "nifty_sma_200": None, "nifty_rsi_14": None,
+        "nifty_macd_line": None, "nifty_macd_signal": None, "nifty_macd_hist": None,
+        "nifty_bb_upper": None, "nifty_bb_lower": None, "nifty_bb_pct_b": None, "nifty_bb_width": None,
+        "nifty_dist_sma_20_pct": None, "nifty_dist_sma_50_pct": None, "nifty_dist_sma_200_pct": None,
+        "nifty_ret_1d_pct": None, "nifty_ret_5d_pct": None, "nifty_ret_20d_pct": None,
+    }
+    if live_nifty_spot <= 0:
+        return empty_res
+
+    historical_closes = fetch_or_get_daily_closes(client)
+    if not historical_closes:
+        return empty_res
+
+    # Append live Nifty spot as today's forming daily close
+    all_closes = historical_closes + [live_nifty_spot]
+    df = pd.DataFrame({"close": all_closes})
+
+    # 1. EMAs & SMAs
+    df["ema_9"] = df["close"].ewm(span=9, adjust=False).mean()
+    df["ema_12"] = df["close"].ewm(span=12, adjust=False).mean()
+    df["ema_26"] = df["close"].ewm(span=26, adjust=False).mean()
+    df["sma_20"] = df["close"].rolling(window=min(20, len(df))).mean()
+    df["sma_50"] = df["close"].rolling(window=min(50, len(df))).mean()
+    df["sma_200"] = df["close"].rolling(window=min(200, len(df))).mean()
+
+    # 2. RSI 14
+    delta = df["close"].diff()
+    gain = (delta.where(delta > 0, 0.0)).rolling(window=14).mean()
+    loss = (-delta.where(delta < 0, 0.0)).rolling(window=14).mean()
+    rs = gain / loss
+    df["rsi_14"] = 100.0 - (100.0 / (1.0 + rs))
+
+    # 3. MACD (12, 26, 9)
+    df["macd_line"] = df["ema_12"] - df["ema_26"]
+    df["macd_signal"] = df["macd_line"].ewm(span=9, adjust=False).mean()
+    df["macd_hist"] = df["macd_line"] - df["macd_signal"]
+
+    # 4. Bollinger Bands (20, 2)
+    std_20 = df["close"].rolling(window=min(20, len(df))).std()
+    df["bb_upper"] = df["sma_20"] + (2.0 * std_20)
+    df["bb_lower"] = df["sma_20"] - (2.0 * std_20)
+    bb_range = df["bb_upper"] - df["bb_lower"]
+    df["bb_pct_b"] = (df["close"] - df["bb_lower"]) / bb_range.replace(0, 1.0)
+    df["bb_width"] = bb_range / df["sma_20"].replace(0, 1.0)
+
+    # 5. Normalized Distance % to Moving Averages (Stationary ML features)
+    df["dist_sma_20_pct"] = ((df["close"] - df["sma_20"]) / df["sma_20"].replace(0, 1.0)) * 100.0
+    df["dist_sma_50_pct"] = ((df["close"] - df["sma_50"]) / df["sma_50"].replace(0, 1.0)) * 100.0
+    df["dist_sma_200_pct"] = ((df["close"] - df["sma_200"]) / df["sma_200"].replace(0, 1.0)) * 100.0
+
+    # 6. Multi-period Percentage Returns
+    df["ret_1d_pct"] = df["close"].pct_change(1) * 100.0
+    df["ret_5d_pct"] = df["close"].pct_change(5) * 100.0
+    df["ret_20d_pct"] = df["close"].pct_change(20) * 100.0
+
+    latest = df.iloc[-1]
+
+    def _clean_val(v, decimals=2):
+        return round(float(v), decimals) if pd.notna(v) else None
+
+    return {
+        "nifty_ema_9": _clean_val(latest["ema_9"]),
+        "nifty_sma_20": _clean_val(latest["sma_20"]),
+        "nifty_sma_50": _clean_val(latest["sma_50"]),
+        "nifty_sma_200": _clean_val(latest["sma_200"]),
+        "nifty_rsi_14": _clean_val(latest["rsi_14"]),
+        "nifty_macd_line": _clean_val(latest["macd_line"]),
+        "nifty_macd_signal": _clean_val(latest["macd_signal"]),
+        "nifty_macd_hist": _clean_val(latest["macd_hist"]),
+        "nifty_bb_upper": _clean_val(latest["bb_upper"]),
+        "nifty_bb_lower": _clean_val(latest["bb_lower"]),
+        "nifty_bb_pct_b": _clean_val(latest["bb_pct_b"], 4),
+        "nifty_bb_width": _clean_val(latest["bb_width"], 4),
+        "nifty_dist_sma_20_pct": _clean_val(latest["dist_sma_20_pct"]),
+        "nifty_dist_sma_50_pct": _clean_val(latest["dist_sma_50_pct"]),
+        "nifty_dist_sma_200_pct": _clean_val(latest["dist_sma_200_pct"]),
+        "nifty_ret_1d_pct": _clean_val(latest["ret_1d_pct"]),
+        "nifty_ret_5d_pct": _clean_val(latest["ret_5d_pct"]),
+        "nifty_ret_20d_pct": _clean_val(latest["ret_20d_pct"]),
+    }

{kitecli-0.2.9 → kitecli-0.3.1}/cli/kite_manager.py

@@ -1103,3 +1103,58 @@ class KiteAccountManager(BaseBrokerManager):
             logger.warning("Failed to fetch LTP/tokens from Zerodha: %s", exc)
             return {}
 
+    def get_order_margin(
+        self,
+        account_key: str,
+        tradingsymbol: str,
+        transaction_type: str,
+        quantity: int,
+        price: float | None = None,
+        product: str = "NRML",
+        exchange: str = "NFO",
+        order_type: str = "LIMIT",
+    ) -> dict[str, Any]:
+        """Calculate margin required using Zerodha kite.order_margins()."""
+        kite = self._clients.get(account_key)
+        if not kite or not self.is_authenticated(account_key):
+            return {"status": "error", "message": "Account not authenticated"}
+
+        try:
+            p_val = price if price is not None else 0.0
+            order_param = {
+                "exchange": exchange,
+                "tradingsymbol": tradingsymbol,
+                "transaction_type": transaction_type.upper(),
+                "variety": "regular",
+                "product": product.upper(),
+                "order_type": order_type.upper() if price is not None else "MARKET",
+                "quantity": abs(quantity),
+                "price": p_val,
+                "trigger_price": 0,
+            }
+
+            margin_resp = kite.order_margins([order_param])
+            if isinstance(margin_resp, list) and len(margin_resp) > 0:
+                m_info = margin_resp[0]
+                total_margin = m_info.get("total")
+                if total_margin is None:
+                    total_margin = m_info.get("margin_required", 0.0)
+                return {
+                    "status": "success",
+                    "total": float(total_margin),
+                    "span": float(m_info.get("span", 0.0)),
+                    "exposure": float(m_info.get("exposure", 0.0)),
+                    "option_premium": float(m_info.get("option_premium", 0.0)),
+                    "detail": m_info,
+                }
+            return {"status": "error", "message": "Empty margin response from Zerodha"}
+        except Exception as exc:
+            logger.warning("Zerodha order_margins fetch failed for %s: %s", tradingsymbol, exc)
+            if price and price > 0 and transaction_type.upper() == "BUY":
+                return {
+                    "status": "success",
+                    "total": round(abs(quantity) * price, 2),
+                    "is_estimated": True,
+                }
+            return {"status": "error", "message": str(exc)}
+

{kitecli-0.2.9 → kitecli-0.3.1}/cli/kotak_manager.py

@@ -1026,7 +1026,7 @@ class KotakTicker:
     def _on_close(self, message: Any = None) -> None:
         logger.info("Kotak Neo WebSocket closed: %s", message or "Session closed")
         msg_str = str(message or "").lower()
-        is_auth_error = any(x in msg_str for x in ["session has been closed", "unauthorized", "invalid token"])
+        is_auth_error = any(x in msg_str for x in ["unauthorized", "invalid token", "token expired", "100008"])
         
         if is_auth_error:
             logger.error("Kotak Neo WebSocket closed due to session expiry/auth failure: %s (mapped code=403)", message)
@@ -1042,7 +1042,8 @@ class KotakTicker:
 
     def _on_error(self, error: Any) -> None:
         error_str = str(error).lower()
-        code = 403 if ("unauthorized" in error_str or "auth" in error_str or "session" in error_str or "token" in error_str) else 0
+        is_auth = any(x in error_str for x in ["unauthorized", "invalid token", "token expired", "100008"]) and not ("session has been closed" in error_str or "session closed" in error_str)
+        code = 403 if is_auth else 0
         logger.error("Kotak Neo WebSocket error: %s (mapped code=%s)", error, code)
         if self.on_error:
             self.on_error(self, code, str(error))
@@ -1202,3 +1203,46 @@ class KotakTicker:
                 if self.on_order_update:
                     self.on_order_update(self, norm_data)
 
+    def get_order_margin(
+        self,
+        account_key: str,
+        tradingsymbol: str,
+        transaction_type: str,
+        quantity: int,
+        price: float | None = None,
+        product: str = "NRML",
+        exchange: str = "NFO",
+        order_type: str = "LIMIT",
+    ) -> dict[str, Any]:
+        """Calculate margin required for Kotak Neo orders."""
+        client = self._clients.get(account_key)
+        if not client or not self.is_authenticated(account_key):
+            return {"status": "error", "message": "Kotak account not authenticated"}
+
+        try:
+            p_val = price if price is not None else 0.0
+            if hasattr(client, "margin_required") and callable(getattr(client, "margin_required")):
+                margin_resp = client.margin_required(
+                    exchange_segment=exchange,
+                    price=str(p_val),
+                    product=product,
+                    quantity=str(abs(quantity)),
+                    token=tradingsymbol,
+                    transaction_type=transaction_type.upper(),
+                )
+                if isinstance(margin_resp, dict) and "margin" in margin_resp:
+                    return {
+                        "status": "success",
+                        "total": float(margin_resp.get("margin", 0.0)),
+                    }
+        except Exception as exc:
+            logger.debug("Kotak SDK margin_required call failed: %s", exc)
+
+        if price and price > 0:
+            return {
+                "status": "success",
+                "total": round(abs(quantity) * price, 2),
+                "is_estimated": True,
+            }
+        return {"status": "error", "message": "Kotak margin estimation unavailable"}
+