tradingapi 0.2.1__tar.gz → 0.3.0__tar.gz

{tradingapi-0.2.1 → tradingapi-0.3.0}/PKG-INFO

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

{tradingapi-0.2.1 → tradingapi-0.3.0}/pyproject.toml

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

tradingapi-0.3.0/tradingapi/allocation.py

@@ -0,0 +1,163 @@
+"""
+Allocation helpers for budget-based position sizing.
+
+Strategies read their daily pct from ~/onedrive/.tradingapi/allocations/master_allocation_today.yaml,
+then call these helpers at each entry decision to derive a live per-entry target margin.
+"""
+
+from __future__ import annotations
+
+import datetime as dt
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import yaml
+
+if TYPE_CHECKING:
+    pass
+
+_ALLOCATIONS_DIR = Path(os.path.expanduser("~/onedrive/.tradingapi/allocations"))
+_TODAY_SYMLINK = _ALLOCATIONS_DIR / "master_allocation_today.yaml"
+
+
+def load_today_allocation(broker_name: str, strategy_name: str) -> float:
+    """Return the pct (0.0–1.0) allocated to strategy_name on broker_name today.
+
+    Reads master_allocation_today.yaml (a symlink to today's dated file).
+    Raises FileNotFoundError if the symlink/file is missing.
+    Raises ValueError if the date in the file does not match today.
+    Returns 0.0 if the strategy is listed with pct == 0 (inactive today).
+    Raises KeyError if the broker/strategy is not found in the file at all.
+    """
+    if not _TODAY_SYMLINK.exists():
+        raise FileNotFoundError(
+            f"Master allocation file not found: {_TODAY_SYMLINK}. "
+            "Run generate_master_allocation.py before starting strategies."
+        )
+
+    with open(_TODAY_SYMLINK) as f:
+        data = yaml.safe_load(f)
+
+    file_date = str(data.get("date", "")).strip()
+    today_str = dt.date.today().isoformat()
+    if file_date != today_str:
+        raise ValueError(
+            f"Master allocation file is stale: file date={file_date!r}, today={today_str!r}. "
+            "Regenerate with generate_master_allocation.py."
+        )
+
+    broker_key = broker_name.strip().upper()
+    brokers = data.get("brokers", {})
+    if broker_key not in brokers:
+        raise KeyError(
+            f"Broker {broker_key!r} not found in master allocation. "
+            f"Available brokers: {list(brokers.keys())}"
+        )
+
+    strategies = brokers[broker_key].get("strategies", {})
+    strategy_key = strategy_name.strip().upper()
+    if strategy_key not in strategies:
+        raise KeyError(
+            f"Strategy {strategy_key!r} not found under broker {broker_key!r} in master allocation. "
+            f"Available strategies: {list(strategies.keys())}"
+        )
+
+    entry = strategies[strategy_key]
+    return float(entry.get("pct", 0.0))
+
+
+def broker_capital(broker) -> float:
+    """Fetch live total capital from broker: cash + collateral."""
+    caps = broker.get_available_capital()
+    return float(caps.get("cash", 0.0)) + float(caps.get("collateral", 0.0))
+
+
+def current_utilisation(broker, strategy_name: str) -> float:
+    """Sum of margin currently consumed by open positions of this strategy.
+
+    Calls broker.get_margin_requirement() for each open position (net=False).
+    Exchange is read from Redis per position; defaults to NSE if missing.
+    """
+    from tradingapi.utils import get_pnl_table, hget_with_default
+
+    try:
+        pnl = get_pnl_table(broker, strategy_name, refresh_status=True)
+    except Exception:
+        return 0.0
+
+    if pnl.empty:
+        return 0.0
+
+    open_mask = (pnl["entry_quantity"].fillna(0) + pnl["exit_quantity"].fillna(0)) != 0
+    exit_empty = pnl["exit_time"].fillna("").astype(str).str.strip().isin(["", "0", "NaT"])
+    open_pnl = pnl.loc[open_mask | exit_empty]
+
+    total = 0.0
+    for _, row in open_pnl.iterrows():
+        combo_symbol = str(row.get("symbol", "")).strip()
+        if not combo_symbol:
+            continue
+        net_qty = float(row.get("entry_quantity", 0) or 0) + float(row.get("exit_quantity", 0) or 0)
+        if net_qty == 0:
+            continue
+        # Signed: positive = long, negative = short.
+        # parse_combo_symbol handles both simple and combo symbols uniformly.
+        order_size = int(net_qty)
+
+        entry_keys_str = str(row.get("entry_keys", "")).strip()
+        first_key = entry_keys_str.split()[0] if entry_keys_str else ""
+        exchange = hget_with_default(broker, first_key, "exchange", "NSE") if first_key else "NSE"
+
+        try:
+            margin = broker.get_margin_requirement(combo_symbol, order_size, exchange)
+            if margin is not None:
+                total += float(margin)
+        except Exception:
+            pass
+    return total
+
+
+def remaining_budget(budget: float, utilised: float) -> float:
+    return max(0.0, budget - utilised)
+
+
+def _remaining_factor_sum(open_positions: int, max_positions: int, decay: float, min_frac: float) -> float:
+    """Sum of decay fractions for future legs [open_positions, max_positions)."""
+    return float(sum(
+        max(min_frac, decay ** k)
+        for k in range(open_positions, max_positions)
+    ))
+
+
+def scalping_entry_target(
+    remaining: float,
+    open_positions: int,
+    max_positions: int,
+    decay: float,
+    min_frac: float,
+) -> float:
+    """Target margin for the next scalping entry given remaining budget.
+
+    Entry 1 (0 open): remaining / sum([1.0, 0.75, 0.5625]) ≈ remaining / 2.3125
+    Entry 2 (1 open): remaining / sum([0.75, 0.5625]) ≈ remaining / 1.3125
+    Entry 3 (2 open): remaining / 0.5625 → clamped to remaining (last leg gets all that's left)
+    """
+    if open_positions >= max_positions:
+        return 0.0
+    factor_sum = _remaining_factor_sum(open_positions, max_positions, decay, min_frac)
+    if factor_sum <= 0:
+        return remaining
+    raw = remaining / factor_sum
+    return min(raw, remaining)
+
+
+def strangle_entry_target(budget_now: float, remaining: float, scheduled_entries: int) -> float:
+    """Target margin for the next strangle entry.
+
+    Equal weighting across scheduled entries, clamped to what's actually left.
+    """
+    if scheduled_entries <= 0:
+        return remaining
+    equal_share = budget_now / scheduled_entries
+    return min(equal_share, remaining)

{tradingapi-0.2.1 → tradingapi-0.3.0}/tradingapi/broker_base.py

@@ -1076,7 +1076,7 @@ class BrokerBase(ABC):
         pass
 
     def get_margin_requirement(
-        self, combo_symbol: str, order_size: int, exchange: str = "NSE", mds: Optional[str] = None
+        self, combo_symbol: str, order_size: int, exchange: str = "NSE", mds: Optional[str] = None, net: bool = False
     ) -> Optional[float]:
         """Default broker margin hook. Brokers can override if supported."""
         _get_trading_logger().log_warning(

{tradingapi-0.2.1 → tradingapi-0.3.0}/tradingapi/config.py

@@ -541,6 +541,22 @@ def get_config() -> Config:
     return cast(Config, _config_instance)
 
 
+def get_fno_freeze_limit(broker_name: str, underlying: str) -> Optional[int]:
+    """Return max contracts per FNO order for (broker, underlying).
+
+    Values in tradingapi.yaml are total contracts (= lots × lot_size).
+    Returns None if no limit is configured for the broker/underlying.
+    """
+    try:
+        cfg = get_config()
+        freeze_cfg = cfg.get("freeze_limits") or {}
+        broker_map = (freeze_cfg.get("brokers") or {}).get(str(broker_name).strip().upper(), {})
+        val = broker_map.get(str(underlying).strip().upper())
+        return int(val) if val is not None else None
+    except Exception:
+        return None
+
+
 # Example usage with enhanced error handling
 if __name__ == "__main__":
     try:

{tradingapi-0.2.1 → tradingapi-0.3.0}/tradingapi/dhan.py

@@ -778,7 +778,7 @@ class Dhan(BrokerBase):
         combo_symbol=lambda x: isinstance(x, str) and len(x.strip()) > 0,
         order_size=lambda x: isinstance(x, (int, float)) and int(x) != 0,
     )
-    def get_margin_requirement(self, combo_symbol: str, order_size: int, exchange: str = "NSE", mds=None) -> float:
+    def get_margin_requirement(self, combo_symbol: str, order_size: int, exchange: str = "NSE", mds=None, net: bool = False) -> float:
         """Return basket margin required for a single-leg or multi-leg combo."""
         try:
             if self.api is None:
@@ -826,8 +826,8 @@ class Dhan(BrokerBase):
 
             payload = {
                 "dhanClientId": self.api.client_id,
-                "includePosition": False,
-                "includeOrder": False,
+                "includePosition": net,
+                "includeOrder": net,
                 "includeOrders": False,
                 "scripList": scripts,
                 "scripts": scripts,

{tradingapi-0.2.1 → tradingapi-0.3.0}/tradingapi/fivepaisa.py

@@ -35,10 +35,65 @@ def _filter_epoch_historical_rows(rows: List["HistoricalData"]) -> List["Histori
     return [row for row in rows if getattr(row, "date", None) != dt.datetime(1970, 1, 1)]
 from py5paisa import FivePaisaClient
 
+
+def _patch_py5paisa_for_mom(api) -> None:
+    """Fix three upstream py5paisa bugs that break multi_order_Margin:
+
+      1. session is httpx.Client with 5s default timeout. Bump to 10s as a
+         safety margin (normal MOM responses are sub-second).
+      2. self.payload = GENERIC_PAYLOAD is a reference assignment, so each
+         call accumulates stale body keys across calls; the polluted body
+         makes the 5paisa server hang past 5s. Reset to a fresh deep copy
+         before each MOM call.
+      3. order_request() does log_response(res["body"]["Message"]) for the
+         MOM branch, but the MOM response has no "Message" key — the KeyError
+         is raised at the subscript (not inside log_response), is swallowed
+         by the bare except, and the function silently returns None. Inject
+         an empty "Message" into the response by wrapping session.post for
+         the duration of the MOM call so the subscript succeeds and
+         res["body"] is returned normally.
+    """
+    if getattr(api, "_tradingapi_patched", False):
+        return
+
+    import copy
+    from py5paisa.const import GENERIC_PAYLOAD
+
+    try:
+        api.session.timeout = 10
+    except Exception:
+        pass
+
+    original_mom = api.multi_order_Margin
+    original_post = api.session.post
+
+    def post_with_message_key(*args, **kwargs):
+        response = original_post(*args, **kwargs)
+        try:
+            data = response.json()
+            if isinstance(data, dict) and isinstance(data.get("body"), dict):
+                data["body"].setdefault("Message", "")
+                response.json = lambda: data  # type: ignore[method-assign]
+        except Exception:
+            pass
+        return response
+
+    def fixed_multi_order_Margin(**order):
+        api.payload = copy.deepcopy(GENERIC_PAYLOAD)
+        api.session.post = post_with_message_key  # type: ignore[method-assign]
+        try:
+            return original_mom(**order)
+        finally:
+            api.session.post = original_post  # type: ignore[method-assign]
+
+    api.multi_order_Margin = fixed_multi_order_Margin
+    api._tradingapi_patched = True
+
 from .broker_base import BrokerBase, Brokers, HistoricalData, Order, OrderInfo, OrderStatus, Price, _normalize_as_of_date
 from .config import get_config
 from .utils import (
     delete_broker_order_id,
+    get_price,
     json_serializer_default,
     parse_combo_symbol,
     set_starting_internal_ids_int,
@@ -47,6 +102,7 @@ from .utils import (
 from .exceptions import (
     ConfigurationError,
     DataError,
+    MarginError,
     RedisError,
     SymbolError,
     TradingAPIError,
@@ -840,6 +896,129 @@ class FivePaisa(BrokerBase):
             except Exception:
                 pass
 
+    @log_execution_time
+    @validate_inputs(
+        combo_symbol=lambda x: isinstance(x, str) and len(x.strip()) > 0,
+        order_size=lambda x: isinstance(x, (int, float)) and int(x) != 0,
+    )
+    def get_margin_requirement(self, combo_symbol: str, order_size: int, exchange: str = "NSE", mds=None, net: bool = False) -> float:
+        """Return margin requirement via py5paisa multi_order_Margin API."""
+        try:
+            if self.api is None:
+                raise BrokerConnectionError("FivePaisa API not connected")
+
+            exch_key = str(exchange or "").upper()[0]
+            if exch_key not in self.exchange_mappings:
+                raise MarginError(f"Exchange {exchange!r} not loaded in symbol map")
+
+            symbol_map = self.exchange_mappings[exch_key]["symbol_map"]
+            exchange_map = self.exchange_mappings[exch_key]["exchange_map"]
+            exchangetype_map = self.exchange_mappings[exch_key]["exchangetype_map"]
+
+            order_requests = []
+            for long_symbol, leg_ratio in parse_combo_symbol(combo_symbol).items():
+                net_qty = int(order_size) * int(leg_ratio)
+                if net_qty == 0:
+                    continue
+
+                scrip_code = symbol_map.get(long_symbol)
+                if scrip_code is None:
+                    raise MarginError(f"ScripCode not found for {long_symbol!r}")
+
+                exch = exchange_map.get(long_symbol, "N")
+                exch_type = exchangetype_map.get(long_symbol, "D")
+                order_type = "B" if net_qty > 0 else "S"
+
+                quote = get_price(self, long_symbol, checks=["bid", "ask"], exchange=exchange, mds=mds)
+                price_candidates = [quote.last, quote.ask, quote.bid, quote.prior_close]
+                price = next((float(v) for v in price_candidates if not pd.isna(v) and float(v) > 0), 0.0)
+
+                order_requests.append({
+                    "Exch": exch,
+                    "ExchType": exch_type,
+                    "ScripCode": int(scrip_code),
+                    "ScripData": "",
+                    "PlaceModifyCancel": "P",
+                    "OrderType": order_type,
+                    "Price": price,
+                    "Qty": abs(net_qty),
+                    "IsIntraday": False,
+                })
+
+            if not order_requests:
+                raise MarginError(f"No valid legs resolved from combo_symbol={combo_symbol!r}")
+
+            _patch_py5paisa_for_mom(self.api)
+            body = self.api.multi_order_Margin(
+                CoverPositions="Y" if net else "N",
+                Orders=order_requests,
+            )
+            if body is None:
+                raise MarginError("multi_order_Margin returned None")
+            total = body.get("TotalMarginRequired")
+            if total is None:
+                raise MarginError(f"Unexpected MultiOrderMargin response: {body}")
+            if float(total) < 0:
+                raise MarginError(f"MultiOrderMargin returned {total} (market may be closed or scrip invalid)")
+
+            return float(total)
+
+        except (ValidationError, MarginError):
+            raise
+        except Exception as e:
+            context = create_error_context(
+                combo_symbol=combo_symbol,
+                order_size=order_size,
+                exchange=exchange,
+                error=str(e),
+            )
+            raise MarginError(f"Failed to calculate FivePaisa margin requirement: {str(e)}", context)
+
+    @log_execution_time
+    @validate_inputs(
+        combo_symbol=lambda x: isinstance(x, str) and len(x.strip()) > 0,
+        order_size=lambda x: isinstance(x, (int, float)) and int(x) != 0,
+    )
+    def get_margin_requirement_new(self, combo_symbol: str, order_size: int, exchange: str = "NSE", mds=None) -> float:
+        """Return local NSE SPAN margin for a single-leg or multi-leg combo."""
+        try:
+            if str(exchange or "").upper() not in ("NSE", "N"):
+                raise MarginError(f"FivePaisa SPAN margin currently supports NSE only, got exchange={exchange}")
+
+            from .span import SpanEngine
+
+            span_cache_dir = os.path.join(config.get("datapath", os.getcwd()), "span_cache")
+            engine = SpanEngine(
+                download_dir=span_cache_dir,
+                lot_size_lookup=lambda symbol: self.get_min_lot_size(symbol, exchange=exchange),
+            )
+
+            for long_symbol, leg_ratio in parse_combo_symbol(combo_symbol).items():
+                net_qty = int(order_size) * int(leg_ratio)
+                if net_qty == 0:
+                    continue
+
+                quote = self.get_quote(long_symbol, exchange=exchange)
+                price_candidates = [quote.last, quote.ask, quote.bid, quote.prior_close]
+                price = next((float(v) for v in price_candidates if not pd.isna(v) and float(v) > 0), None)
+                if price is None:
+                    raise MarginError(f"No usable market price found for {long_symbol}")
+
+                engine.add_position(long_symbol, net_qty, price)
+
+            return float(engine.calculate_margin()["total_margin"])
+
+        except (ValidationError, MarginError):
+            raise
+        except Exception as e:
+            context = create_error_context(
+                combo_symbol=combo_symbol,
+                order_size=order_size,
+                exchange=exchange,
+                error=str(e),
+            )
+            raise MarginError(f"Failed to calculate FivePaisa margin requirement: {str(e)}", context)
+
     @log_execution_time
     @retry_on_error(max_retries=2, delay=1.0, backoff_factor=2.0)
     def is_connected(self):

{tradingapi-0.2.1 → tradingapi-0.3.0}/tradingapi/flattrade.py

@@ -40,7 +40,7 @@ def _validate_datetime_input(date_input):
 
 def _filter_epoch_historical_rows(rows: List["HistoricalData"]) -> List["HistoricalData"]:
     return [row for row in rows if getattr(row, "date", None) != dt.datetime(1970, 1, 1)]
-from NorenRestApiPy.NorenApi import NorenApi
+from NorenRestApiPy.NorenApi import NorenApi, position as FlatTradePosition
 
 from .broker_base import BrokerBase, Brokers, HistoricalData, Order, OrderInfo, OrderStatus, Price, _normalize_as_of_date
 from .config import get_config
@@ -52,6 +52,7 @@ from .error_handling import validate_inputs, log_execution_time, retry_on_error
 from .exceptions import (
     ConfigurationError,
     DataError,
+    MarginError,
     RedisError,
     SymbolError,
     TradingAPIError,
@@ -1014,6 +1015,86 @@ class FlatTrade(BrokerBase):
             trading_logger.log_error("Error getting available capital", e, {"broker": self.broker.name})
             raise MarketDataError(f"Failed to get available capital: {str(e)}")
 
+    def get_margin_requirement(self, combo_symbol: str, order_size: int, exchange: str = "NSE", mds=None, net: bool = False) -> float:
+        """Return margin requirement via FlatTrade ``span_calculator`` (Noren API)."""
+        if self.api is None:
+            raise BrokerConnectionError("FlatTrade API not connected")
+
+        exch_key = str(exchange or "").upper()[0]
+        if exch_key not in self.exchange_mappings:
+            raise MarginError(f"Exchange {exchange!r} not loaded in symbol map")
+
+        exchange_map = self.exchange_mappings[exch_key]["exchange_map"]
+
+        # Build set of index base symbols from _IND___ entries across all exchanges
+        index_bases: set[str] = set()
+        for mapping in self.exchange_mappings.values():
+            for sym in mapping["symbol_map"]:
+                if sym.endswith("_IND___"):
+                    index_bases.add(sym.split("_")[0])
+
+        positions = []
+        for long_symbol, leg_ratio in parse_combo_symbol(combo_symbol).items():
+            net_qty = int(order_size) * int(leg_ratio)
+            if net_qty == 0:
+                continue
+
+            parts = long_symbol.split("_")
+            if len(parts) < 5:
+                raise MarginError(f"Cannot parse long_symbol {long_symbol!r} for span_calculator")
+
+            base, inst_type, expiry_str = parts[0], parts[1], parts[2]
+            opt_side, strike = parts[3], parts[4]
+
+            try:
+                dt.datetime.strptime(expiry_str, "%Y%m%d")
+                exd_int = int(expiry_str)
+            except ValueError:
+                raise MarginError(f"Cannot parse expiry date in {long_symbol!r}")
+
+            is_index = base in index_bases
+            if inst_type == "FUT":
+                instname = "FUTIDX" if is_index else "FUTSTK"
+                optt = "XX"
+                strprc_val = -1.0
+            elif inst_type == "OPT":
+                instname = "OPTIDX" if is_index else "OPTSTK"
+                optt = "PE" if opt_side == "PUT" else "CE"
+                strprc_val = float(strike)
+            else:
+                raise MarginError(f"Unknown instrument type {inst_type!r} in {long_symbol!r}")
+
+            exch = exchange_map.get(long_symbol)
+            if exch is None:
+                raise MarginError(f"Exchange not found for {long_symbol!r}")
+
+            pos = FlatTradePosition()
+            pos.prd = "M"
+            pos.exch = exch
+            pos.instname = instname
+            pos.symname = base
+            pos.exd = exd_int
+            pos.optt = optt
+            pos.strprc = strprc_val
+            pos.buyqty = abs(net_qty) if net_qty > 0 else 0
+            pos.sellqty = abs(net_qty) if net_qty < 0 else 0
+            pos.netqty = net_qty
+            positions.append(pos)
+
+        if not positions:
+            raise MarginError(f"No valid legs resolved from combo_symbol={combo_symbol!r}")
+
+        actid = config.get(f"{self.account_key}.USER") or ""
+        result = self.api.span_calculator(actid, positions)
+
+        if result is None or result.get("stat") != "Ok":
+            raise MarginError(f"span_calculator failed: {result}")
+
+        span = float(result.get("span", 0) or 0)
+        expo = float(result.get("expo", 0) or 0)
+        return span + expo
+
+
     @log_execution_time
     @retry_on_error(max_retries=2, delay=1.0, backoff_factor=2.0)
     def disconnect(self):