kitecli 0.2.4__tar.gz → 0.2.5__tar.gz

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

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

{kitecli-0.2.4 → kitecli-0.2.5}/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,27 @@ 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:
+                        mgr._clients[account_key].limits()
+                        is_valid = True
+                    except Exception as exc:
+                        msg = str(exc).lower()
+                        is_auth_error = any(x in msg for x in ["100008", "unauthorized", "invalid token", "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 +181,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.5}/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.5}/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.5}/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 ────────────────────────────────────────────────────────
@@ -320,30 +301,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
@@ -936,6 +894,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 +952,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 +996,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 +1051,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 +1081,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.5}/cli/live_session.py

@@ -1228,29 +1228,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:

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

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

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

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