tradingapi 0.1.7__tar.gz → 0.2.0__tar.gz

{tradingapi-0.1.7 → tradingapi-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tradingapi
-Version: 0.1.7
+Version: 0.2.0
 Summary: Trade integration with brokers
 Author-email: Pankaj Sharma <sharma.pankaj.kumar@gmail.com>
 License-Expression: MIT

{tradingapi-0.1.7 → tradingapi-0.2.0}/pyproject.toml

@@ -28,7 +28,7 @@ packages = ["tradingapi"]
 
 [project]
 name = "tradingapi"
-version = "0.1.7"
+version = "0.2.0"
 description = "Trade integration with brokers"
 readme = "README.md"
 license = "MIT"

{tradingapi-0.1.7 → tradingapi-0.2.0}/tradingapi/__init__.py

@@ -180,13 +180,26 @@ class TradingAPILogger:
             pass
         return {}
 
+    def _sanitize_extra(self, context: Optional[dict] = None) -> dict:
+        """Rename reserved LogRecord keys in extra context to avoid logging failures."""
+        extra = dict(context or {})
+        reserved_keys = set(logging.makeLogRecord({}).__dict__.keys()) | {
+            "message",
+            "asctime",
+        }
+        sanitized = {}
+        for key, value in extra.items():
+            new_key = f"context_{key}" if key in reserved_keys else key
+            sanitized[new_key] = value
+        return sanitized
+
     def log_error(
         self, message: str, error: Optional[Exception] = None, context: Optional[dict] = None, exc_info: bool = True
     ):
         """Log an error with structured context. Extra values are sanitized to single-line so
         parse_log_errors.py can reliably match the ERROR line (same format as other tradingapi logs).
         """
-        extra = context or {}
+        extra = self._sanitize_extra(context)
         if error:
             extra["error_type"] = type(error).__name__
             # Keep error_message single-line so the log line matches parse_log_errors structured format
@@ -206,7 +219,7 @@ class TradingAPILogger:
 
     def log_warning(self, message: str, context: Optional[dict] = None):
         """Log a warning with structured context."""
-        extra = context or {}
+        extra = self._sanitize_extra(context)
 
         # Add caller information
         caller_info = self._get_caller_info()
@@ -216,7 +229,7 @@ class TradingAPILogger:
 
     def log_info(self, message: str, context: Optional[dict] = None):
         """Log an info message with structured context."""
-        extra = context or {}
+        extra = self._sanitize_extra(context)
 
         # Add caller information
         caller_info = self._get_caller_info()
@@ -226,7 +239,7 @@ class TradingAPILogger:
 
     def log_debug(self, message: str, context: Optional[dict] = None):
         """Log a debug message with structured context."""
-        extra = context or {}
+        extra = self._sanitize_extra(context)
 
         # Add caller information
         caller_info = self._get_caller_info()

{tradingapi-0.1.7 → tradingapi-0.2.0}/tradingapi/broker_base.py

@@ -11,8 +11,6 @@ import pandas as pd
 import pytz
 import redis
 
-from chameli.dateutils import parse_datetime
-
 logger = logging.getLogger(__name__)
 
 from .exceptions import (
@@ -26,6 +24,7 @@ from .exceptions import (
     create_error_context,
 )
 from .error_handling import retry_on_error, safe_execute, log_execution_time, handle_broker_errors, validate_inputs
+from chameli.dateutils import parse_datetime
 
 # Removed trading_logger import to avoid circular import issues
 

{tradingapi-0.1.7 → tradingapi-0.2.0}/tradingapi/dhan.py

@@ -14,8 +14,6 @@ import requests
 import redis
 import pytz
 
-from chameli.dateutils import parse_datetime
-
 from dhanhq import dhanhq as dhanhq_sdk
 try:
     from dhanhq import DhanContext, MarketFeed
@@ -36,6 +34,7 @@ from .broker_base import (
     _normalize_as_of_date,
 )
 from .config import get_config
+from chameli.dateutils import parse_datetime
 from .utils import (
     _set_long_symbol_if_not_combo,
     delete_broker_order_id,
@@ -517,7 +516,7 @@ class Dhan(BrokerBase):
     @retry_on_error(max_retries=2, delay=1.0, backoff_factor=2.0)
     def get_available_capital(self) -> Dict[str, float]:
         """
-        Returns dict with 'cash' and 'collateral' keys.
+            Returns dict with 'cash', 'collateral', and 'used' keys.
 
         Dhan's get_fund_limits() response data fields:
             availabelBalance, collateralAmount, utilisedAmount, …
@@ -533,9 +532,10 @@ class Dhan(BrokerBase):
             data = result.get("data", {})
             cash = float(data.get("availabelBalance", 0) or 0)
             collateral = float(data.get("collateralAmount", 0) or 0)
+            used = float(data.get("utilisedAmount", 0) or 0)
 
-            trading_logger.log_debug("Available capital retrieved", {"cash": cash, "collateral": collateral})
-            return {"cash": cash, "collateral": collateral}
+            trading_logger.log_debug("Available capital retrieved", {"cash": cash, "collateral": collateral, "used": used})
+            return {"cash": cash, "collateral": collateral, "used": used}
 
         except (BrokerConnectionError, MarketDataError):
             raise

{tradingapi-0.1.7 → tradingapi-0.2.0}/tradingapi/fivepaisa.py

@@ -875,6 +875,26 @@ class FivePaisa(BrokerBase):
                         except (ValueError, TypeError):
                             continue
 
+            used = 0.0
+            used_fields = [
+                "UtilizedMargin",
+                "UsedMargin",
+                "MarginUsed",
+                "BookedMargin",
+                "TotalMargin",
+                "utilizedmargin",
+                "usedmargin",
+                "marginused",
+                "MarginUtilized",
+            ]
+            for field in used_fields:
+                if field in margin_data[0]:
+                    try:
+                        used = float(margin_data[0][field])
+                        break
+                    except (ValueError, TypeError):
+                        continue
+
             trading_logger.log_debug(
                 "Available capital retrieved",
                 {
@@ -882,10 +902,11 @@ class FivePaisa(BrokerBase):
                     "funds_payln": funds_payln,
                     "cash": cash,
                     "collateral": collateral,
+                    "used": used,
                     "total_capital": cash + collateral,
                 },
             )
-            return {"cash": cash, "collateral": collateral}
+            return {"cash": cash, "collateral": collateral, "used": used}
 
         except (BrokerConnectionError, MarketDataError):
             raise
@@ -916,6 +937,7 @@ class FivePaisa(BrokerBase):
             if self.api:
                 self.api = None
                 trading_logger.log_info("API reference cleared", {"broker_type": self.broker.name})
+            self.subscribe_thread = None
 
             trading_logger.log_info("Successfully disconnected from FivePaisa", {"broker_type": self.broker.name})
             return True
@@ -3206,6 +3228,32 @@ class FivePaisa(BrokerBase):
                 context = create_error_context(symbols=symbols, exchange=exchange, error=str(e))
                 raise MarketDataError(f"Failed to map exchange: {str(e)}", context)
 
+            def resolve_symbol_and_exchange(json_data):
+                """Resolve a token to the correct symbol/exchange even when the tick exchange key is incomplete."""
+                token = json_data.get("Token")
+                exchange_candidates = []
+                tick_exchange = json_data.get("Exch")
+
+                if tick_exchange in self.exchange_mappings:
+                    exchange_candidates.append(tick_exchange)
+
+                if isinstance(tick_exchange, str) and tick_exchange:
+                    short_exchange = tick_exchange[0]
+                    if short_exchange in self.exchange_mappings and short_exchange not in exchange_candidates:
+                        exchange_candidates.append(short_exchange)
+
+                for exchange_key in exchange_candidates:
+                    symbol = self.exchange_mappings[exchange_key]["symbol_map_reversed"].get(token)
+                    if symbol is not None:
+                        return symbol, exchange_key
+
+                for exchange_key, exchange_mapping in self.exchange_mappings.items():
+                    symbol = exchange_mapping["symbol_map_reversed"].get(token)
+                    if symbol is not None:
+                        return symbol, exchange_key
+
+                return None, tick_exchange
+
             def map_to_price(json_data):
                 """Map JSON data to Price object."""
                 try:
@@ -3220,10 +3268,18 @@ class FivePaisa(BrokerBase):
                     price.high = json_data.get("High", float("nan"))
                     price.low = json_data.get("Low", float("nan"))
                     price.volume = json_data.get("TotalQty", float("nan"))
-                    price.symbol = self.exchange_mappings[json_data["Exch"]]["symbol_map_reversed"].get(
-                        json_data.get("Token")
-                    )
-                    price.exchange = self.map_exchange_for_db(price.symbol, json_data["Exch"])
+                    price.symbol, resolved_exchange = resolve_symbol_and_exchange(json_data)
+                    if price.symbol is None:
+                        trading_logger.log_warning(
+                            "Skipping price data with unmapped token",
+                            {
+                                "token": json_data.get("Token"),
+                                "exchange": json_data.get("Exch"),
+                                "exchange_type": json_data.get("ExchType"),
+                            },
+                        )
+                        return None
+                    price.exchange = self.map_exchange_for_db(price.symbol, resolved_exchange)
                     price.timestamp = self.convert_to_ist(json_data["TickDt"])
                     return price
                 except Exception as e:
@@ -3237,10 +3293,10 @@ class FivePaisa(BrokerBase):
                     json_data = json.loads(data_str)
                     if len(json_data) == 1:
                         price = map_to_price(json_data[0])
-                        if ext_callback:
+                        if price is not None and ext_callback:
                             ext_callback(price)
                 except Exception as e:
-                    trading_logger.log_error("Error processing WebSocket message", e, {"message": message})
+                    trading_logger.log_error("Error processing WebSocket message", e, {"ws_message": message})
 
             def error_data(ws, err):
                 """Handle WebSocket errors."""
@@ -3281,6 +3337,52 @@ class FivePaisa(BrokerBase):
                     trading_logger.log_error("Error in connect_and_receive", e, {"req_data": req_data})
                     raise
 
+            def has_live_stream():
+                """Return True only when the streaming thread and websocket are both usable."""
+                return (
+                    self.subscribe_thread is not None
+                    and self.subscribe_thread.is_alive()
+                    and self.api is not None
+                    and getattr(self.api, "ws", None) is not None
+                    and callable(getattr(self.api.ws, "send", None))
+                )
+
+            def reconnect_stream():
+                """Start a fresh websocket and restore all subscriptions."""
+                try:
+                    if self.api is not None and getattr(self.api, "ws", None) is not None:
+                        self.api.close_data()
+                except Exception:
+                    pass
+                self.subscribe_thread = None
+                req_list_full = expand_symbols_to_request(self.subscribed_symbols)
+                if not req_list_full:
+                    context = create_error_context(operation=operation, symbols=symbols, exchange=exchange)
+                    raise MarketDataError("No symbols to reconnect after socket closure", context)
+                if self.api is None:
+                    raise BrokerConnectionError("API client not initialized")
+                req_data_full = self.api.Request_Feed("mf", "s", req_list_full)
+                self.subscribe_thread = threading.Thread(
+                    target=connect_and_receive,
+                    args=(req_data_full,),
+                    name="MarketDataStreamer",
+                )
+                self.subscribe_thread.start()
+                time.sleep(2)
+                trading_logger.log_info(
+                    "Reconnected after socket closure",
+                    {"subscribed_count": len(self.subscribed_symbols)},
+                )
+
+            def send_stream_request(req_data):
+                """Send an incremental subscribe/unsubscribe over an existing websocket."""
+                if self.api is None:
+                    raise BrokerConnectionError("API client not initialized")
+                ws = getattr(self.api, "ws", None)
+                if ws is None or not callable(getattr(ws, "send", None)):
+                    raise AttributeError("WebSocket client does not support send")
+                ws.send(json.dumps(req_data))
+
             def resolve_exchange_from_symbology(long_symbol: str):
                 """Resolve API exchange code for a symbol from symbology (which exchange's symbol_map contains it)."""
                 for exch in self.exchange_mappings:
@@ -3367,7 +3469,7 @@ class FivePaisa(BrokerBase):
                     req_data = self.api.Request_Feed("mf", operation, req_list)
 
                     # Start the connection and receiving data in a separate thread
-                    if self.subscribe_thread is None:
+                    if not has_live_stream():
                         self.subscribe_thread = threading.Thread(
                             target=connect_and_receive, args=(req_data,), name="MarketDataStreamer"
                         )
@@ -3379,36 +3481,13 @@ class FivePaisa(BrokerBase):
                             "Requesting streaming for existing connection", {"req_data": json.dumps(req_data)}
                         )
                         try:
-                            self.api.ws.send(json.dumps(req_data))
-                        except WebSocketConnectionClosedException:
+                            send_stream_request(req_data)
+                        except (AttributeError, WebSocketConnectionClosedException):
                             trading_logger.log_info(
                                 "WebSocket closed, reconnecting...",
                                 {"operation": operation, "symbols_count": len(symbols), "exchange": exchange},
                             )
-                            try:
-                                if self.api is not None:
-                                    self.api.close_data()
-                            except Exception:
-                                pass
-                            self.subscribe_thread = None
-                            req_list_full = expand_symbols_to_request(self.subscribed_symbols)
-                            if not req_list_full:
-                                context = create_error_context(operation=operation, symbols=symbols, exchange=exchange)
-                                raise MarketDataError("No symbols to reconnect after socket closure", context)
-                            if self.api is None:
-                                raise BrokerConnectionError("API client not initialized")
-                            req_data_full = self.api.Request_Feed("mf", "s", req_list_full)
-                            self.subscribe_thread = threading.Thread(
-                                target=connect_and_receive,
-                                args=(req_data_full,),
-                                name="MarketDataStreamer",
-                            )
-                            self.subscribe_thread.start()
-                            time.sleep(2)
-                            trading_logger.log_info(
-                                "Reconnected after socket closure",
-                                {"subscribed_count": len(self.subscribed_symbols)},
-                            )
+                            reconnect_stream()
                             # New connection already has full subscription; no need to send again
                 else:
                     trading_logger.log_warning(
@@ -3440,6 +3519,7 @@ class FivePaisa(BrokerBase):
             try:
                 if self.api is not None:
                     self.api.close_data()
+                self.subscribe_thread = None
                 trading_logger.log_info("Streaming stopped successfully")
             except Exception as e:
                 context = create_error_context(error=str(e))

{tradingapi-0.1.7 → tradingapi-0.2.0}/tradingapi/flattrade.py

@@ -902,16 +902,25 @@ class FlatTrade(BrokerBase):
 
             cash_float = float(cash)
             collateral = float(limits.get("collateral", 0))
+            used = 0.0
+            for field in ("usedmargin", "UsedMargin", "utilisedamount", "UtilisedAmount", "marginused", "MarginUsed"):
+                if field in limits:
+                    try:
+                        used = float(limits[field])
+                        break
+                    except (ValueError, TypeError):
+                        continue
 
             trading_logger.log_debug(
                 "Available capital retrieved",
                 {
                     "cash": cash_float,
                     "collateral": collateral,
+                    "used": used,
                     "total_capital": cash_float + collateral,
                 },
             )
-            return {"cash": cash_float, "collateral": collateral}
+            return {"cash": cash_float, "collateral": collateral, "used": used}
 
         except (BrokerConnectionError, MarketDataError):
             raise

{tradingapi-0.1.7 → tradingapi-0.2.0}/tradingapi/shoonya.py

@@ -796,16 +796,36 @@ class Shoonya(BrokerBase):
                     except (ValueError, TypeError):
                         continue
 
+            used = 0.0
+            used_fields = [
+                "usedmargin",
+                "UsedMargin",
+                "utilisedamount",
+                "UtilisedAmount",
+                "marginused",
+                "MarginUsed",
+                "spanused",
+                "SpanUsed",
+            ]
+            for field in used_fields:
+                if field in limits:
+                    try:
+                        used = float(limits[field])
+                        break
+                    except (ValueError, TypeError):
+                        continue
+
             trading_logger.log_debug(
                 "Available capital retrieved",
                 {
                     "cash": cash_float,
                     "collateral": collateral,
+                    "used": used,
                     "total_capital": cash_float + collateral,
                     "broker": self.broker.name,
                 },
             )
-            return {"cash": cash_float, "collateral": collateral}
+            return {"cash": cash_float, "collateral": collateral, "used": used}
 
         except (BrokerConnectionError, MarketDataError):
             raise

{tradingapi-0.1.7 → tradingapi-0.2.0}/tradingapi/utils.py

@@ -368,6 +368,9 @@ def _safe_parse_json_or_dict(json_str):
                 }
                 return eval(json_str, safe_globals, {})
             except Exception as eval_error:
+                parsed_loose_info = _parse_loose_additional_info(json_str)
+                if parsed_loose_info is not None:
+                    return parsed_loose_info
                 raise DataError(
                     f"Cannot parse as JSON or Python dict: {str(e)}",
                     {
@@ -379,6 +382,57 @@ def _safe_parse_json_or_dict(json_str):
                 )
 
 
+def _parse_loose_additional_info(info_str):
+    info_str = str(info_str).strip()
+    if not info_str:
+        return {}
+
+    import shlex
+
+    def _coerce_value(value):
+        lower_value = value.lower()
+        if lower_value == "true":
+            return True
+        if lower_value == "false":
+            return False
+        if lower_value == "none":
+            return None
+        try:
+            if any(ch in value for ch in [".", "e", "E"]):
+                return float(value)
+            return int(value)
+        except ValueError:
+            return value
+
+    try:
+        tokens = shlex.split(info_str)
+    except ValueError:
+        tokens = info_str.split()
+
+    parsed = {}
+    message_tokens = []
+    for token in tokens:
+        token_parts = [part for part in token.split(",") if part]
+        consumed_key_value = False
+        for part in token_parts:
+            if "=" not in part:
+                if not consumed_key_value:
+                    message_tokens.append(part)
+                continue
+            key, value = part.split("=", 1)
+            if not key:
+                continue
+            parsed[key] = _coerce_value(value)
+            consumed_key_value = True
+        if "=" not in token and not token_parts:
+            message_tokens.append(token)
+
+    if message_tokens:
+        parsed["message"] = " ".join(message_tokens)
+
+    return parsed or {"message": info_str}
+
+
 @log_execution_time
 def _merge_additional_info(old_info, new_info):
     """

{tradingapi-0.1.7 → tradingapi-0.2.0}/tradingapi.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tradingapi
-Version: 0.1.7
+Version: 0.2.0
 Summary: Trade integration with brokers
 Author-email: Pankaj Sharma <sharma.pankaj.kumar@gmail.com>
 License-Expression: MIT