kitecli 0.2.4__tar.gz → 0.2.6__tar.gz

{kitecli-0.2.4 → kitecli-0.2.6}/PKG-INFO

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

{kitecli-0.2.4 → kitecli-0.2.6}/cli/api_client.py

@@ -7,8 +7,12 @@ identical to the previous single-broker version so that cli/main.py and
 cli/live_session.py require zero changes.
 """
 
+import logging
 from concurrent.futures import ThreadPoolExecutor
 from cli.kite_manager import KiteAccountManager
+from cli.config import remove_session
+
+logger = logging.getLogger(__name__)
 
 
 class KCLIClientError(Exception):
@@ -132,8 +136,29 @@ class KCLIClient:
                 )
                 _account_manager_map[account_key] = mgr
                 acct.setdefault("api_key", account_key)
+
+                # Validation: verify token with a REST query (limits)
+                is_valid = False
+                if mgr.is_authenticated(account_key):
+                    try:
+                        resp = mgr._clients[account_key].limits()
+                        from cli.kotak_manager import _check_neo_error
+                        _check_neo_error(resp)
+                        is_valid = True
+                    except Exception as exc:
+                        msg = str(exc).lower()
+                        is_auth_error = any(x in msg for x in ["100008", "100022", "1037", "unauthorized", "invalid token", "invalid session", "session expired", "session has been closed", "session closed"])
+                        if is_auth_error:
+                            logger.info("Kotak validation failed (expired/invalid) for %s: %s", name, exc)
+                            mgr._authenticated[account_key] = False
+                            remove_session(f"kotak:{account_key}")
+                        else:
+                            # Network/timeout error: fallback to assuming token is valid
+                            logger.warning("Kotak validation query failed due to network/other issue. Assuming valid. Error: %s", exc)
+                            is_valid = True
+
                 # Attempt auto-login for Kotak
-                if not mgr.is_authenticated(account_key):
+                if not is_valid:
                     success = mgr.auto_login(account_key)
                     return {
                         "name": name, "api_key": account_key,
@@ -158,7 +183,29 @@ class KCLIClient:
                 )
                 _account_manager_map[api_key] = _kite_manager
 
+                # Validation: verify token with a REST query (profile)
+                is_valid = False
                 if _kite_manager.is_authenticated(api_key):
+                    try:
+                        _kite_manager._clients[api_key].profile()
+                        is_valid = True
+                    except Exception as exc:
+                        try:
+                            from kiteconnect.exceptions import TokenException, PermissionException
+                        except Exception:
+                            TokenException = PermissionException = ()
+                        msg = str(exc).lower()
+                        is_auth_error = isinstance(exc, (TokenException, PermissionException)) or any(x in msg for x in ["403", "401", "unauthorized", "token", "session"])
+                        if is_auth_error:
+                            logger.info("Zerodha validation failed (expired/invalid) for %s: %s", name, exc)
+                            _kite_manager._authenticated[api_key] = False
+                            remove_session(api_key)
+                        else:
+                            # Network/timeout error: fallback to assuming token is valid
+                            logger.warning("Zerodha validation query failed due to network/other issue. Assuming valid. Error: %s", exc)
+                            is_valid = True
+
+                if is_valid:
                     return {
                         "name": name, "api_key": api_key,
                         "login_url": login_url, "auto_logged_in": True,

{kitecli-0.2.4 → kitecli-0.2.6}/cli/config.py

@@ -6,12 +6,19 @@ stored at ~/.kcli/config.yaml.
 """
 
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Any, Dict
+import json
+import logging
+import threading
 
 import yaml
 
 CONFIG_DIR = Path.home() / ".kcli"
 CONFIG_FILE = CONFIG_DIR / "config.yaml"
+SESSIONS_FILE = CONFIG_DIR / "sessions.json"
+
+sessions_lock = threading.RLock()
+logger = logging.getLogger(__name__)
 
 DEFAULT_CONFIG = {
     "accounts": [
@@ -94,3 +101,43 @@ def create_default_config() -> dict:
     """
     save_config(DEFAULT_CONFIG)
     return DEFAULT_CONFIG
+
+
+def load_sessions() -> Dict[str, Any]:
+    """Load the shared sessions from ~/.kcli/sessions.json thread-safely."""
+    with sessions_lock:
+        if not SESSIONS_FILE.exists():
+            return {}
+        try:
+            with open(SESSIONS_FILE, "r") as f:
+                return json.load(f)
+        except Exception as exc:
+            logger.error("Failed to load sessions: %s", exc)
+            return {}
+
+
+def save_session(key: str, value: Any) -> None:
+    """Save a session value thread-safely to ~/.kcli/sessions.json."""
+    with sessions_lock:
+        sessions = load_sessions()
+        sessions[key] = value
+        try:
+            SESSIONS_FILE.parent.mkdir(parents=True, exist_ok=True)
+            with open(SESSIONS_FILE, "w") as f:
+                json.dump(sessions, f, indent=2)
+        except Exception as exc:
+            logger.error("Failed to save session for %s: %s", key, exc)
+
+
+def remove_session(key: str) -> None:
+    """Remove a session key thread-safely from ~/.kcli/sessions.json."""
+    with sessions_lock:
+        sessions = load_sessions()
+        if key in sessions:
+            del sessions[key]
+            try:
+                SESSIONS_FILE.parent.mkdir(parents=True, exist_ok=True)
+                with open(SESSIONS_FILE, "w") as f:
+                    json.dump(sessions, f, indent=2)
+            except Exception as exc:
+                logger.error("Failed to remove session for %s: %s", key, exc)

{kitecli-0.2.4 → kitecli-0.2.6}/cli/kite_manager.py

@@ -12,29 +12,7 @@ from cli.base_manager import BaseBrokerManager
 
 logger = logging.getLogger(__name__)
 
-SESSIONS_FILE = Path.home() / ".kcli" / "sessions.json"
-
-
-def _load_sessions() -> dict[str, str]:
-    if not SESSIONS_FILE.exists():
-        return {}
-    try:
-        with open(SESSIONS_FILE, "r") as f:
-            return json.load(f)
-    except Exception as exc:
-        logger.error("Failed to load sessions: %s", exc)
-        return {}
-
-
-def _save_session(api_key: str, access_token: str) -> None:
-    sessions = _load_sessions()
-    sessions[api_key] = access_token
-    try:
-        SESSIONS_FILE.parent.mkdir(parents=True, exist_ok=True)
-        with open(SESSIONS_FILE, "w") as f:
-            json.dump(sessions, f, indent=2)
-    except Exception as exc:
-        logger.error("Failed to save session for %s: %s", api_key[:8], exc)
+from cli.config import load_sessions as _load_sessions, save_session as _save_session
 
 
 class KiteAccountManager(BaseBrokerManager):

{kitecli-0.2.4 → kitecli-0.2.6}/cli/kotak_manager.py

@@ -98,26 +98,7 @@ def _check_neo_error(resp: Any) -> None:
 
 # ── session persistence (shared file with Zerodha tokens) ─────────────────────
 
-def _load_sessions() -> dict[str, str]:
-    if not SESSIONS_FILE.exists():
-        return {}
-    try:
-        with open(SESSIONS_FILE, "r") as f:
-            return json.load(f)
-    except Exception as exc:
-        logger.error("Failed to load sessions: %s", exc)
-        return {}
-
-
-def _save_session(key: str, token: str) -> None:
-    sessions = _load_sessions()
-    sessions[key] = token
-    try:
-        SESSIONS_FILE.parent.mkdir(parents=True, exist_ok=True)
-        with open(SESSIONS_FILE, "w") as f:
-            json.dump(sessions, f, indent=2)
-    except Exception as exc:
-        logger.error("Failed to save session for %s: %s", key, exc)
+from cli.config import load_sessions as _load_sessions, save_session as _save_session
 
 
 # ── KotakAccountManager ────────────────────────────────────────────────────────
@@ -156,7 +137,9 @@ class KotakAccountManager(BaseBrokerManager):
 
     def init_account(self, account_key: str, **credentials) -> str:
         """ABC entry point — delegates to init_account_kotak."""
-        return self.init_account_kotak(consumer_key=account_key, **credentials)
+        creds = dict(credentials)
+        creds.pop("consumer_key", None)
+        return self.init_account_kotak(consumer_key=account_key, **creds)
 
     def init_account_kotak(
         self,
@@ -284,17 +267,19 @@ class KotakAccountManager(BaseBrokerManager):
             except Exception:
                 logger.debug("Kotak REST response body (raw): %s", resp.text[:200])
 
-            # Check for IP mismatch error (stCode 1037) or Session expired (stCode 100008)
+            # Check for IP mismatch error (stCode 1037), Session expired (stCode 100008, 100022), or HTTP 401
             try:
-                resp_json = resp.json()
+                resp_json = resp.json() if resp.text else {}
                 if isinstance(resp_json, dict):
                     st_code = resp_json.get("stCode")
                     err_msg = str(resp_json.get("errMsg", "")).lower()
                     if (
-                        st_code == 1037 or 
-                        st_code == 100008 or 
-                        "session ip" in err_msg or 
-                        "unauthorized" in err_msg
+                        resp.status_code == 401 or
+                        st_code in (1037, 100008, 100022) or
+                        "session ip" in err_msg or
+                        "unauthorized" in err_msg or
+                        "invalid session" in err_msg or
+                        "invalid token" in err_msg
                     ):
                         logger.info("Kotak session invalid (stCode=%s, msg='%s') for account '%s'. Triggering auto-login...", st_code, resp_json.get("errMsg"), name)
                         if self.auto_login(consumer_key):
@@ -320,30 +305,7 @@ class KotakAccountManager(BaseBrokerManager):
 
         client.api_client.rest_client.request = _proxied_request
         if proxy:
-            logger.info("Kotak account '%s': HTTP proxy enabled (%s…)", name, proxy[:20])
-
-            # Also monkeypatch websocket-client (used by Kotak Neo WebSocket) to route over the proxy.
-            try:
-                import websocket as _ws_lib
-                from urllib.parse import urlparse as _urlparse
-                _parsed = _urlparse(proxy)
-                _proxy_host = _parsed.hostname
-                _proxy_port = _parsed.port
-                _proxy_auth = (_parsed.username, _parsed.password) if _parsed.username and _parsed.password else None
-                
-                _orig_run_forever = _ws_lib.WebSocketApp.run_forever
-                def _proxied_run_forever(self, *args, **kwargs):
-                    kwargs.setdefault("http_proxy_host", _proxy_host)
-                    kwargs.setdefault("http_proxy_port", _proxy_port)
-                    kwargs.setdefault("proxy_type", "http")
-                    if _proxy_auth:
-                        kwargs.setdefault("http_proxy_auth", _proxy_auth)
-                    return _orig_run_forever(self, *args, **kwargs)
-                
-                _ws_lib.WebSocketApp.run_forever = _proxied_run_forever
-                logger.info("Kotak account '%s': WebSocket proxy monkeypatch applied", name)
-            except Exception as e:
-                logger.error("Failed to apply WebSocket proxy patch for Kotak: %s", e)
+            logger.info("Kotak account '%s': HTTP proxy enabled for order APIs (%s…)", name, proxy[:20])
         self._clients[consumer_key] = client
         self._account_names[consumer_key] = name or consumer_key
         self._authenticated[consumer_key] = False
@@ -697,6 +659,7 @@ class KotakAccountManager(BaseBrokerManager):
 
         try:
             resp = client.limits()
+            _check_neo_error(resp)
             if isinstance(resp, dict):
                 data = resp.get("data", resp)
                 net = data.get("Net", data.get("net"))
@@ -936,6 +899,10 @@ class KotakAccountManager(BaseBrokerManager):
         return KotakTicker(account_key, self.get_access_token(account_key), client)
 
 
+def _dummy_callback(*args, **kwargs):
+    pass
+
+
 # ── KotakTicker WebSocket Wrapper ─────────────────────────────────────────────
 
 class KotakTicker:
@@ -990,6 +957,13 @@ class KotakTicker:
                 self._reconnect_timer.cancel()
                 self._reconnect_timer = None
         logger.info("Closing Kotak Neo WebSocket (api_key=%s…)...", self.api_key[:8])
+        
+        # Clear client callbacks to avoid recursive callback noise during close
+        self.client.on_open = _dummy_callback
+        self.client.on_message = _dummy_callback
+        self.client.on_error = _dummy_callback
+        self.client.on_close = _dummy_callback
+
         neo_ws = getattr(self.client, "NeoWebSocket", None)
         if neo_ws:
             if getattr(neo_ws, "hsWebsocket", None):
@@ -1027,6 +1001,16 @@ 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"])
+        
+        if is_auth_error:
+            logger.error("Kotak Neo WebSocket closed due to session expiry/auth failure: %s (mapped code=403)", message)
+            if self.on_error:
+                # Map to 403 so live_session stops reconnecting and prompts user to re-init
+                self.on_error(self, 403, str(message or "Session closed"))
+            return
+
         if self.on_close:
             self.on_close(self, 1000, str(message or "Closed"))
         if self.reconnect and not self._stop_reconnect:
@@ -1072,6 +1056,10 @@ class KotakTicker:
         
         logger.info("Kotak Neo WS: Attempting reconnection now...")
         try:
+            # Temporarily stub callbacks to avoid recursive on_error/on_close triggers during cleanup
+            self.client.on_error = _dummy_callback
+            self.client.on_close = _dummy_callback
+
             # First, clean up sockets
             neo_ws = getattr(self.client, "NeoWebSocket", None)
             if neo_ws:
@@ -1098,6 +1086,11 @@ class KotakTicker:
             self.client.subscribe_to_orderfeed()
         except Exception as e:
             logger.error("Kotak Neo WS: Reconnection attempt failed: %s", e)
+            # Re-register open/message/error/close hooks on client
+            self.client.on_open = self._on_open
+            self.client.on_message = self._on_message
+            self.client.on_error = self._on_error
+            self.client.on_close = self._on_close
             self._trigger_reconnect()
 
     def _on_message(self, message: Any) -> None:

{kitecli-0.2.4 → kitecli-0.2.6}/cli/live_session.py

@@ -1003,6 +1003,14 @@ class KCLILiveSession:
             " Advisor ",
             make_click_handler("advisor")
         ))
+        fragments.append(("", " "))
+
+        # Tab 5: Help
+        fragments.append((
+            "class:tab.active" if self.info_mode == "help" else "class:tab.inactive",
+            " Help ",
+            make_click_handler("help")
+        ))
         
         return fragments
 
@@ -1162,6 +1170,12 @@ class KCLILiveSession:
     async def _initial_fetch_and_connect(self) -> None:
         """Initial fetch of data and connect all WebSockets."""
         self.log_message("Initializing connections and fetching data...")
+
+        # Ensure accounts are validated & auto-logged in
+        try:
+            await self._run_api_call(self.client.init_accounts, self.accounts)
+        except Exception as e:
+            self.log_message(f"[#ff8700]Account init warning:[/#] {e}")
         
         # Fire off REST data fetch in the background so it doesn't block WebSockets
         if hasattr(self, "app") and self.app and self.app.loop:
@@ -1188,7 +1202,7 @@ class KCLILiveSession:
             )
 
         # Connect WebSockets for accounts that support it (Zerodha and Kotak).
-        for idx, acct in enumerate(self.accounts):
+        for acct in self.accounts:
             api_key = acct.get("api_key")
             broker = acct.get("broker", "zerodha").lower()
             access_token = self.client.get_access_token(api_key)
@@ -1201,9 +1215,6 @@ class KCLILiveSession:
                 )
                 continue
 
-            if idx > 0:
-                await asyncio.sleep(0.2)
-
             if api_key and (access_token or broker == "kotak"):
                 try:
                     if broker == "kotak":
@@ -1228,29 +1239,8 @@ class KCLILiveSession:
                     ticker.on_close = self._make_on_close(api_key)
                     ticker.on_error = self._make_on_error(api_key)
 
-                    # Parse proxy if configured for this account (Zerodha WS does not require IP whitelisting, direct is faster)
-                    proxy_str = acct.get("proxy")
-                    proxy_dict = None
-                    if broker != "zerodha" and proxy_str:
-                        from urllib.parse import urlparse
-                        try:
-                            p_str = proxy_str if "://" in proxy_str else f"http://{proxy_str}"
-                            parsed = urlparse(p_str)
-                            if parsed.hostname and parsed.port:
-                                proxy_dict = {
-                                    "host": parsed.hostname,
-                                    "port": int(parsed.port),
-                                }
-                                if parsed.username and parsed.password:
-                                    proxy_dict["username"] = parsed.username
-                                    proxy_dict["password"] = parsed.password
-                        except Exception as p_err:
-                            self.log_message(f"[#ff8700]Failed to parse proxy for {acct.get('name')}:[/#] {p_err}")
-
-                    # connect() only accepts threaded + proxy
+                    # connect() only accepts threaded
                     connect_kwargs = dict(threaded=True)
-                    if proxy_dict:
-                        connect_kwargs["proxy"] = proxy_dict
                     ticker.connect(**connect_kwargs)
                     self.tickers[api_key] = ticker
                 except Exception as exc:
@@ -2341,6 +2331,44 @@ class KCLILiveSession:
                 )
             return
 
+        # Direct commands to switch info pane mode
+        cmd_norm = cmd.strip().lower()
+        if cmd_norm in ("pending", "p", "1", "/1", "/pending"):
+            self.info_mode = "orders_pending"
+            self._update_info_buffer()
+            if hasattr(self, "app") and self.app:
+                self.app.invalidate()
+            self.log_message("Switched info pane to [bold]Pending Orders[/bold].")
+            return
+        elif cmd_norm in ("executed", "e", "ex", "2", "/2", "/executed"):
+            self.info_mode = "orders_executed"
+            self._update_info_buffer()
+            if hasattr(self, "app") and self.app:
+                self.app.invalidate()
+            self.log_message("Switched info pane to [bold]Executed Orders[/bold].")
+            return
+        elif cmd_norm in ("oc", "optionchain", "chain", "3", "/3", "/oc"):
+            self.info_mode = "oc"
+            self._update_info_buffer()
+            if hasattr(self, "app") and self.app:
+                self.app.invalidate()
+            self.log_message("Switched info pane to [bold]Option Chain[/bold].")
+            return
+        elif cmd_norm in ("advisor", "adv", "ai", "4", "/4", "/advisor"):
+            self.info_mode = "advisor"
+            self._update_info_buffer()
+            if hasattr(self, "app") and self.app:
+                self.app.invalidate()
+            self.log_message("Switched info pane to [bold]AI Advisor[/bold].")
+            return
+        elif cmd_norm in ("help", "h", "5", "/5", "/help"):
+            self.info_mode = "help"
+            self._update_info_buffer()
+            if hasattr(self, "app") and self.app:
+                self.app.invalidate()
+            self.log_message("Switched info pane to [bold]Help & Shortcuts[/bold].")
+            return
+
         # Attempt parsing via the unified parser
         try:
             parsed_cmds = parse_command_line(cmd)
@@ -3847,6 +3875,59 @@ class KCLILiveSession:
             lines.append("No pending orders across all accounts.")
         return "\n".join(lines)
 
+    def _build_help_text(self) -> str:
+        """Return formatted keyboard shortcuts & command cheat sheet."""
+        return """=== KiteCLI Keyboard & Command Cheat Sheet ===
+
+1. TAB SWITCHING (RIGHT PANE)
+   Type at prompt:
+     p or pending or 1  -> Switch to Pending Orders tab
+     e or executed or 2 -> Switch to Executed Orders tab
+     oc or chain or 3   -> Switch to Option Chain tab
+     adv or advisor or 4-> Switch to AI Advisor tab
+     h or help or 5     -> Switch to this Help tab
+
+   Universal Hotkeys:
+     Ctrl + P           -> Pending Orders
+     Ctrl + E           -> Executed Orders
+     Ctrl + O           -> Option Chain
+     Ctrl + G           -> AI Advisor
+     Ctrl + H           -> Help
+
+   Function Keys / Alt:
+     F1 / F2 / F3 / F4 / F5
+     Option+1 / 2 / 3 / 4 / 5 (or Esc then 1..5)
+     Mouse Click: Click directly on any tab title in header bar
+
+2. ORDER PLACEMENT & TRADING COMMANDS
+   Buy / Sell Orders:
+     b <symbol> <qty> [price]     -> Buy limit/market (e.g. b NIFTY26JUL22500PE 100 1.40)
+     s <symbol> <qty> [price]     -> Sell limit/market (e.g. s BANKNIFTY26JUL50000CE 15@2.50)
+     b 1 100                       -> Buy 100 qty of active position #1
+     s 2                           -> Sell/exit all qty of active position #2
+
+   Exiting Positions:
+     exit <symbol|id> [price]     -> Exit position by symbol or table ID (e.g. exit 1, exit 2 1.50)
+     exit all [price]              -> Exit all active positions (e.g. exit all)
+
+   Modifying & Cancelling:
+     modify <order_id> [qty] [price] -> Modify open order
+     cancel <order_id>               -> Cancel pending order
+     cancel all                      -> Cancel all open/pending orders
+
+3. SELECTION & SELECTION CLEARING
+   Selection:
+     Click on symbol/account row   -> Target specific position/account
+     Esc                             -> Clear active selection / reset account filter
+
+4. GLOBAL NAVIGATION & CONTROL
+   Tab           -> Cycle focus (Input box -> Positions -> Right Pane)
+   Ctrl + R      -> Search command history
+   Ctrl + Left   -> Narrow left pane split width
+   Ctrl + Right  -> Widen left pane split width
+   Ctrl + C      -> Exit KiteCLI
+"""
+
     def _update_info_buffer(self, reset_scroll: bool = True) -> None:
         """Push current info_mode text into the info_buffer.
 
@@ -3867,6 +3948,8 @@ class KCLILiveSession:
             except Exception as exc:
                 self._last_advisor_text = f"=== Tuesday Expiry Advisor ===\n\nFailed to plan: {exc}"
             text = self._last_advisor_text
+        elif self.info_mode == "help":
+            text = self._build_help_text()
         else:
             text = self._last_oc_text
         if reset_scroll:
@@ -4238,8 +4321,10 @@ class KCLILiveSession:
                 nxt = self.input_field.control
             event.app.layout.focus(nxt)
 
-        # Ctrl+1/2/3/4 & F1-F4 — switch info pane content
+        # Ctrl+1/2/3/4, Ctrl+P/E/O/G, Alt/Esc+1/2/3/4, F1-F4 — switch info pane content
         @kb.add("c-1")
+        @kb.add("c-p")
+        @kb.add("escape", "1")
         @kb.add("f1")
         def _c1(event):
             self.info_mode = "orders_pending"
@@ -4247,6 +4332,8 @@ class KCLILiveSession:
             event.app.invalidate()
 
         @kb.add("c-2")
+        @kb.add("c-e")
+        @kb.add("escape", "2")
         @kb.add("f2")
         def _c2(event):
             self.info_mode = "orders_executed"
@@ -4254,6 +4341,8 @@ class KCLILiveSession:
             event.app.invalidate()
 
         @kb.add("c-3")
+        @kb.add("c-o")
+        @kb.add("escape", "3")
         @kb.add("f3")
         def _c3(event):
             self.info_mode = "oc"
@@ -4261,12 +4350,23 @@ class KCLILiveSession:
             event.app.invalidate()
 
         @kb.add("c-4")
+        @kb.add("c-g")
+        @kb.add("escape", "4")
         @kb.add("f4")
         def _c4(event):
             self.info_mode = "advisor"
             self._update_info_buffer()
             event.app.invalidate()
 
+        @kb.add("c-5")
+        @kb.add("c-h")
+        @kb.add("escape", "5")
+        @kb.add("f5")
+        def _c5(event):
+            self.info_mode = "help"
+            self._update_info_buffer()
+            event.app.invalidate()
+
         # Ctrl+Left/Right — adjust left/right pane split
         @kb.add("c-left")
         def _narrow_left(event):

{kitecli-0.2.4 → kitecli-0.2.6}/cli/main.py

@@ -206,6 +206,7 @@ def live() -> None:
         display_error("No accounts configured. Edit your config file to add accounts.")
         raise typer.Exit(code=1)
     client = _build_client(config)
+    client.init_accounts(accounts)
 
     # Launch interactive session
     session = KCLILiveSession(client, accounts)

{kitecli-0.2.4 → kitecli-0.2.6}/kitecli.egg-info/PKG-INFO

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

{kitecli-0.2.4 → kitecli-0.2.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "kitecli"
-version = "0.2.4"
+version = "0.2.6"
 description = "KiteCLI — Multi-account, multi-broker trading positions viewer (Zerodha + Kotak Neo)"
 readme = "README.md"
 requires-python = ">=3.10"