Price-Time Priority and Queue Position

# Queue position at the best bid: how many lots sit ahead of you, and your fill odds.
import os
from datetime import date, timedelta

from openalgo import api
from scipy.stats import poisson

client = api(
    api_key=os.getenv("OPENALGO_API_KEY", "your_api_key_here"),
    host=os.getenv("OPENALGO_HOST", "http://127.0.0.1:5000"),
)

# MCX near-month crude trades late, so its book is liveliest; fall back to a liquid NSE name.
# (symbol, exchange, lot size, tick size)
CANDIDATES = [
    ("CRUDEOIL20JUL26FUT", "MCX", 100, 1.0),
    ("RELIANCE", "NSE", 500, 0.05),
]
YOUR_LOTS = 5        # the passive BUY you want to rest at the best bid
SELL_SHARE = 0.5     # share of traded flow that arrives as sells hitting the bid
DEPTH_MINUTES = 2    # illustrative resting depth = this many minutes of real flow
HORIZON = 5          # minutes, the window for the fill-probability estimate


def recent_flow(symbol, exchange):
    end = date(2026, 6, 26)                        # last trading day (Friday)
    start = end - timedelta(days=10)
    return client.history(symbol=symbol, exchange=exchange, interval="1m",
                          start_date=start.isoformat(), end_date=end.isoformat())


for symbol, exchange, lot, tick in CANDIDATES:
    snap = client.depth(symbol=symbol, exchange=exchange).get("data", {})
    df = recent_flow(symbol, exchange)
    if df is None or len(df) == 0:
        continue
    flow = float(df["volume"].median())            # real lots traded per minute
    bids, asks = snap.get("bids", []), snap.get("asks", [])
    live = bool(bids) and bids[0].get("quantity", 0) > 0

    if live:                                        # market open: read the real touch
        best_bid = float(bids[0]["price"])
        ahead = float(bids[0]["quantity"])
        spread = float(asks[0]["price"]) - best_bid
        mode = "live book"
    else:                                           # off-hours: rebuild around the real last price
        ltp = float(snap.get("ltp") or df["close"].iloc[-1])
        best_bid = round(ltp / tick) * tick - tick
        spread = tick                               # a liquid contract trades about one tick wide
        ahead = round(DEPTH_MINUTES * flow)         # illustrative resting depth from real flow
        mode = "reconstructed (book closed; depth seeded from real 1m flow)"

    sell_rate = flow * SELL_SHARE                   # lots/min hitting the bid
    wait_front = ahead / sell_rate                  # time for the queue ahead to clear
    wait_full = (ahead + YOUR_LOTS) / sell_rate     # time to also fill your lots
    mu = sell_rate * HORIZON                         # expected sells over the horizon
    p_full = float(poisson.sf(ahead + YOUR_LOTS - 1, mu))   # P(N >= ahead + your lots)
    queue_value = (spread / 2.0) * lot              # half-spread earned per lot vs the mid

    print(f"{symbol}  [{mode}]")
    print(f"  best bid {best_bid:g}   spread {spread:g}   tick {tick:g}   lot {lot}")
    print(f"  resting ahead of you at the best bid : {ahead:.0f} lots")
    print(f"  your passive BUY joins the back      : {YOUR_LOTS} lots")
    print(f"  sell flow hitting the bid (real)     : {sell_rate:.1f} lots/min "
          f"(median {flow:.0f} lots/min traded)")
    print(f"  expected wait to reach the front     : {wait_front:.1f} min")
    print(f"  expected wait to fully fill          : {wait_full:.1f} min")
    print(f"  P(full fill within {HORIZON} min)            : {p_full * 100:.0f}%")
    print(f"  a good queue spot is worth           : Rs {queue_value:.0f}/lot "
          f"(Rs {queue_value * YOUR_LOTS:.0f} on {YOUR_LOTS} lots)")
    print(f"SUMMARY {symbol}: {ahead:.0f} lots ahead, ~{wait_front:.1f} min to the front, "
          f"~{p_full * 100:.0f}% full fill in {HORIZON} min, queue spot worth Rs {queue_value:.0f}/lot.")
    break

# Watch a FIFO bid queue drain: your position falls as sells fill and orders ahead cancel.
import os
from datetime import date, timedelta
from pathlib import Path

import matplotlib

matplotlib.use("Agg")
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns
from openalgo import api

client = api(
    api_key=os.getenv("OPENALGO_API_KEY", "your_api_key_here"),
    host=os.getenv("OPENALGO_HOST", "http://127.0.0.1:5000"),
)

SYMBOL, EXCHANGE = "CRUDEOIL20JUL26FUT", "MCX"
YOUR_LOTS = 5         # your passive BUY, resting at the back of the best-bid queue
SELL_SHARE = 0.5      # share of flow that arrives as sells hitting the bid
CANCEL_MULT = 1.2     # cancels-ahead per sell (real books cancel more than they trade)
DEPTH_MINUTES = 2     # illustrative depth ahead of you = this many minutes of real flow

# Real per-minute flow from the last trading day drives the event rates.
end = date(2026, 6, 26)
start = end - timedelta(days=10)
df = client.history(symbol=SYMBOL, exchange=EXCHANGE, interval="1m",
                    start_date=start.isoformat(), end_date=end.isoformat())
flow = float(df["volume"].median())               # real lots/min

rng = np.random.default_rng(7)
ahead0 = round(DEPTH_MINUTES * flow)              # lots in front of you when you join
sell_ps = flow * SELL_SHARE / 60.0               # sells per second hitting the bid
cancel_ps = sell_ps * CANCEL_MULT                # cancels-ahead per second (scaled by queue left)

t, ahead, yours = 0, ahead0, YOUR_LOTS
times, ahead_path = [0], [ahead0]
front_t = fill_t = None
while yours > 0 and t < 1800:                     # cap the sim at 30 minutes
    t += 1
    cancels = rng.poisson(cancel_ps * (ahead / ahead0)) if ahead > 0 else 0
    ahead = max(0, ahead - cancels)              # cancels ahead advance you but never fill you
    sells = rng.poisson(sell_ps)
    eat = min(ahead, sells)                       # sells first clear the queue ahead...
    ahead -= eat
    sells -= eat
    if ahead == 0 and front_t is None:
        front_t = t
    if ahead == 0 and sells > 0:                  # ...then fill your lots, FIFO
        yours = max(0, yours - sells)
        if yours == 0 and fill_t is None:
            fill_t = t
    times.append(t)
    ahead_path.append(ahead)

mins = np.array(times) / 60.0
sns.set_theme(style="whitegrid")
fig, ax = plt.subplots(figsize=(8, 4.5))
ax.plot(mins, ahead_path, color="#7c83ff", linewidth=2, label="lots ahead of you")
ax.axhline(0, color="#9a9a9a", linewidth=1)
if front_t:
    ax.axvline(front_t / 60.0, color="#16a34a", linestyle="--", linewidth=1.4,
               label=f"reached front ({front_t / 60.0:.1f} min)")
if fill_t:
    ax.axvline(fill_t / 60.0, color="#dc2626", linestyle="--", linewidth=1.4,
               label=f"fully filled ({fill_t / 60.0:.1f} min)")
ax.set_title(f"{SYMBOL} - your position in the FIFO bid queue draining")
ax.set_xlabel("Minutes after you joined the back of the queue")
ax.set_ylabel("Lots resting ahead of you")
ax.legend(loc="upper right")

out = Path(__file__).with_suffix(".png")
plt.savefig(out, dpi=110, bbox_inches="tight")

filled = "did not fully fill" if fill_t is None else f"fully filled in {fill_t / 60.0:.1f} min"
print(f"SUMMARY {SYMBOL}: joined behind {ahead0} lots, reached the front in "
      f"{(front_t or 0) / 60.0:.1f} min and {filled} (real flow {flow:.0f} lots/min). Saved {out.name}")