15. Positions, PPMMR & Max Buy/Sell

Auth → Equity positions → Equity PPMMR → (Derivatives) → Max buy/sell

from decimal import Decimal

from ssi_sdk import Auth, Data, Trading, Config
from auth_helper import ensure_auth
from helpers import mask_account, require_account

config = Config(
    client_id="<your_client_id>",
    api_key="<your_api_key>",
    api_secret="<your_api_secret>",
    private_key="<your_private_key>",
)
ACCOUNT_NO = "<your_account_no>"
DERIVATIVE_ACCOUNT_NO = None  # set a derivative account number if you have one
SYMBOL = "SSI"


def money(value) -> str:
    return "-" if value is None else f"{value:,.0f}"


require_account(ACCOUNT_NO)

with Auth(config) as auth:
    ensure_auth(auth, otp="<your_otp>")

    with Trading(auth) as trading, Data(auth) as data:
        # Step 1: Equity positions
        print(f"--- Equity positions ({mask_account(ACCOUNT_NO)}) ---")
        positions = trading.portfolio.get_equity_positions(ACCOUNT_NO) or []
        print(f"{'Symbol':<8}{'Qty':>9}{'Sellable':>10}{'T1 buy':>9}{'T2 buy':>9}{'T1 sell':>9}{'T2 sell':>9}{'Cost':>12}")
        for pos in positions:
            print(
                f"{pos.symbol:<8}{pos.quantity:>9}{pos.sellable_quantity:>10}"
                f"{pos.t1_buy_quantity:>9}{pos.t2_buy_quantity:>9}"
                f"{pos.t1_sell_quantity:>9}{pos.t2_sell_quantity:>9}{pos.cost_price:>12,.0f}"
            )
        if not positions:
            print("  (no positions)")

        # Step 2: Equity PPMMR
        print("\n--- Equity PPMMR ---")
        eq = trading.portfolio.get_equity_ppmmr(ACCOUNT_NO)
        if eq is None:
            print("  (no PPMMR data)")
        else:
            print(f"  Purchasing power           : {money(eq.purchasing_power)}")
            print(f"  Margin ratio               : {eq.margin_ratio}")
            print(f"  Total assets / Total debt  : {money(eq.total_assets)} / {money(eq.total_debt)}")
            print(f"  Buy amount T0/T1/T2        : {money(eq.buy_t0)} / {money(eq.buy_t1)} / {money(eq.buy_t2)}")
            print(f"  Sell amount T0/T1/T2       : {money(eq.sell_t0)} / {money(eq.sell_t1)} / {money(eq.sell_t2)}")

        # Step 3: Derivative account (optional)
        if DERIVATIVE_ACCOUNT_NO:
            print(f"\n--- Derivatives ({mask_account(DERIVATIVE_ACCOUNT_NO)}) ---")
            all_pos = trading.portfolio.get_derivative_positions(DERIVATIVE_ACCOUNT_NO) or []
            for group in all_pos:
                for p in group.open_positions:
                    print(f"  OPEN   {p.symbol:<12} long={p.long} short={p.short} net={p.net} floating P/L={money(p.floating_pl)}")
                for p in group.closed_positions:
                    print(f"  CLOSED {p.symbol:<12} long={p.long} short={p.short} net={p.net} trading P/L={money(p.trading_pl)}")
            dv = trading.portfolio.get_derivative_ppmmr(DERIVATIVE_ACCOUNT_NO)
            if dv is not None:
                print(f"  Balance: {money(dv.account_balance)} | Total P/L: {money(dv.total_pl)} | Withdrawable: {money(dv.withdrawable)}")
                print(f"  SSI required margin: {money(dv.margin_req_ssi)} | SSI account ratio: {dv.account_ratio_ssi}")
        else:
            print("\n(Skipping derivatives: derivative_account is not configured)")

        # Step 4: Max buy / sell
        print(f"\n--- Max buy/sell {SYMBOL} ---")
        master = next((m for m in data.market_data.get_master_data() if m.symbol == SYMBOL), None)
        if master is not None and master.ref_price > 0:
            price = Decimal(str(master.ref_price))
            mx = trading.trading.get_max_buy_sell(ACCOUNT_NO, SYMBOL, price)
            print(f"  @ reference price {price}: buy {mx.max_buy_quantity} | sell {mx.max_sell_quantity}"
                  f" | purchasing power {mx.purchasing_power} | margin {mx.margin_ratio}")
        mx_mkt = trading.trading.get_max_buy_sell_at_market_price(ACCOUNT_NO, SYMBOL)
        print(f"  @ market price: buy {mx_mkt.max_buy_quantity} | sell {mx_mkt.max_sell_quantity}")

import asyncio
from decimal import Decimal

from ssi_sdk import AsyncAuth, AsyncData, AsyncTrading, Config
from auth_helper import ensure_auth_async
from helpers import mask_account, require_account

config = Config(...)
ACCOUNT_NO = "<your_account_no>"
SYMBOL = "SSI"


async def main():
    require_account(ACCOUNT_NO)

    async with AsyncAuth(config) as auth:
        await ensure_auth_async(auth, otp="<your_otp>")

        async with AsyncTrading(auth) as trading, AsyncData(auth) as data:
            print(f"--- Equity positions ({mask_account(ACCOUNT_NO)}) ---")
            positions = await trading.portfolio.get_equity_positions(ACCOUNT_NO) or []
            for pos in positions:
                print(f"{pos.symbol:<8} {pos.quantity:>9} T1 buy={pos.t1_buy_quantity} T1 sell={pos.t1_sell_quantity}")

            eq = await trading.portfolio.get_equity_ppmmr(ACCOUNT_NO)
            if eq is not None:
                print(f"Purchasing power: {eq.purchasing_power} | margin: {eq.margin_ratio}")

            master_data = await data.market_data.get_master_data()
            master = next((m for m in master_data if m.symbol == SYMBOL), None)
            if master is not None and master.ref_price > 0:
                price = Decimal(str(master.ref_price))
                mx = await trading.trading.get_max_buy_sell(ACCOUNT_NO, SYMBOL, price)
                print(f"Max buy {mx.max_buy_quantity} | Max sell {mx.max_sell_quantity}")


asyncio.run(main())