Openalgo

Symbol,Lot Size (Apr 2026),Lot Size (May 2026),Lot Size (Jun 2026)
BANKNIFTY,30,30,30
FINNIFTY,60,60,60
MIDCPNIFTY,120,120,120
NIFTY,65,65,65
NIFTYNXT50,25,25,25
360ONE,500,500,500
ABB,125,125,125
ABCAPITAL,3100,3100,3100
ADANIENSOL,675,675,675
ADANIENT,309,309,309
ADANIGREEN,600,600,600
ADANIPORTS,475,475,475
ADANIPOWER,3550,3550,3550
ALKEM,125,125,125
AMBER,100,100,100
AMBUJACEM,1050,1050,1050
ANGELONE,2500,2500,2500
APLAPOLLO,350,350,350
APOLLOHOSP,125,125,125
ASHOKLEY,5000,5000,5000
ASIANPAINT,250,250,250
ASTRAL,425,425,425
AUBANK,1000,1000,1000
AUROPHARMA,550,550,550
AXISBANK,625,625,625
BAJAJ-AUTO,75,75,75
BAJAJFINSV,250,250,250
BAJAJHLDNG,50,50,50
BAJFINANCE,750,750,750
BANDHANBNK,3600,3600,3600
BANKBARODA,2925,2925,2925
BANKINDIA,5200,5200,5200
BDL,350,350,350
BEL,1425,1425,1425
BHARATFORG,500,500,500
BHARTIARTL,475,475,475
BHEL,2625,2625,2625
BIOCON,2500,2500,2500
BLUESTARCO,325,325,325
BOSCHLTD,25,25,25
BPCL,1975,1975,1975
BRITANNIA,125,125,125
BSE,375,375,375
CAMS,750,750,750
CANBK,6750,6750,6750
CDSL,475,475,475
CGPOWER,850,850,850
CHOLAFIN,625,625,625
CIPLA,375,375,375
COALINDIA,1350,1350,1350
COCHINSHIP,400,400,400
COFORGE,375,375,375
COLPAL,225,225,225
CONCOR,1250,1250,1250
CROMPTON,1800,1800,1800
CUMMINSIND,200,200,200
DABUR,1250,1250,1250
DALBHARAT,325,325,325
DELHIVERY,2075,2075,2075
DIVISLAB,100,100,100
DIXON,50,50,50
DLF,825,825,825
DMART,150,150,150
DRREDDY,625,625,625
EICHERMOT,100,100,100
ETERNAL,2425,2425,2425
EXIDEIND,1800,1800,1800
FEDERALBNK,5000,5000,5000
FORCEMOT,25,25,25
FORTIS,775,775,775
GAIL,3150,3150,3150
GLENMARK,375,375,375
GMRAIRPORT,6975,6975,6975
GODFRYPHLP,275,275,275
GODREJCP,500,500,500
GODREJPROP,275,275,275
GRASIM,250,250,250
HAL,150,150,150
HAVELLS,500,500,500
HCLTECH,350,350,350
HDFCAMC,300,300,300
HDFCBANK,550,550,550
HDFCLIFE,1100,1100,1100
HEROMOTOCO,150,150,150
HINDALCO,700,700,700
HINDPETRO,2025,2025,2025
HINDUNILVR,300,300,300
HINDZINC,1225,1225,1225
HUDCO,2775,-,-
HYUNDAI,275,275,275
ICICIBANK,700,700,700
ICICIGI,325,325,325
ICICIPRULI,925,925,925
IDEA,71475,71475,71475
IDFCFIRSTB,9275,9275,9275
IEX,3750,3750,3750
INDHOTEL,1000,1000,1000
INDIANB,1000,1000,1000
INDIGO,150,150,150
INDUSINDBK,700,700,700
INDUSTOWER,1700,1700,1700
INFY,400,400,400
INOXWIND,3575,3575,3575
IOC,4875,4875,4875
IREDA,3450,3450,3450
IRFC,4250,4250,4250
ITC,1600,1600,1600
JINDALSTEL,625,625,625
JIOFIN,2350,2350,2350
JSWENERGY,1000,1000,1000
JSWSTEEL,675,675,675
JUBLFOOD,1250,1250,1250
KALYANKJIL,1175,1175,1175
KAYNES,100,100,100
KEI,175,175,175
KFINTECH,500,500,500
KOTAKBANK,2000,2000,2000
KPITTECH,425,425,425
LAURUSLABS,850,850,850
LICHSGFIN,1000,1000,1000
LICI,700,700,700
LODHA,450,450,450
LT,175,175,175
LTF,2250,2250,2250
LTM,150,150,150
LUPIN,425,425,425
M&M,200,200,200
MANAPPURAM,3000,3000,3000
MANKIND,225,225,225
MARICO,1200,1200,1200
MARUTI,50,50,50
MAXHEALTH,525,525,525
MAZDOCK,200,200,200
MCX,625,625,625
MFSL,400,400,400
MOTHERSON,6150,6150,6150
MOTILALOFS,775,775,775
MPHASIS,275,275,275
MUTHOOTFIN,275,275,275
NAM-INDIA,625,625,625
NATIONALUM,3750,3750,3750
NAUKRI,375,375,375
NBCC,6500,6500,6500
NESTLEIND,500,500,500
NHPC,6400,6400,6400
NMDC,6750,6750,6750
NTPC,1500,1500,1500
NUVAMA,500,500,500
NYKAA,3125,3125,3125
OBEROIRLTY,350,350,350
OFSS,75,75,75
OIL,1400,1400,1400
ONGC,2250,2250,2250
PAGEIND,15,15,15
PATANJALI,900,900,900
PAYTM,725,725,725
PERSISTENT,100,100,100
PETRONET,1900,1900,1900
PFC,1300,1300,1300
PGEL,950,950,950
PHOENIXLTD,350,350,350
PIDILITIND,500,500,500
PIIND,175,175,175
PNB,8000,8000,8000
PNBHOUSING,650,650,650
POLICYBZR,350,350,350
POLYCAB,125,125,125
POWERGRID,1900,1900,1900
POWERINDIA,50,50,50
PPLPHARMA,2625,-,-
PREMIERENE,575,575,575
PRESTIGE,450,450,450
RBLBANK,3175,3175,3175
RECLTD,1400,1400,1400
RELIANCE,500,500,500
RVNL,1525,1525,1525
SAIL,4700,4700,4700
SAMMAANCAP,4300,4300,4300
SBICARD,800,800,800
SBILIFE,375,375,375
SBIN,750,750,750
SHREECEM,25,25,25
SHRIRAMFIN,825,825,825
SIEMENS,175,175,175
SOLARINDS,50,50,50
SONACOMS,1225,1225,1225
SRF,200,200,200
SUNPHARMA,350,350,350
SUPREMEIND,175,175,175
SUZLON,9025,9025,9025
SWIGGY,1300,1300,1300
TATACONSUM,550,550,550
TATAELXSI,100,100,100
TATAPOWER,1450,1450,1450
TATASTEEL,5500,5500,5500
TATATECH,800,-,-
TCS,175,175,175
TECHM,600,600,600
TIINDIA,200,200,200
TITAN,175,175,175
TMPV,800,800,800
TORNTPHARM,250,250,250
TORNTPOWER,425,-,-
TRENT,100,100,100
TVSMOTOR,175,175,175
ULTRACEMCO,50,50,50
UNIONBANK,4425,4425,4425
UNITDSPR,400,400,400
UNOMINDA,550,550,550
UPL,1355,1355,1355
VBL,1125,1125,1125
VEDL,1150,1150,1150
VMM,4850,4850,4850
VOLTAS,375,375,375
WAAREEENER,175,175,175
WIPRO,3000,3000,3000
YESBANK,31100,31100,31100
ZYDUSLIFE,900,900,900

"""Rebalance a basket of equity positions to a target weight.

Workflow:
1. Read current holdings via `client.holdings()`
2. Compute target rupee allocation per symbol (equal-weight or custom)
3. For each symbol: quote -> compute delta qty (target - current)
4. Place all rebalancing orders in one `basketorder` call
5. Verify per-leg success; alert summary

Output folder: openalgo_workspace/execution/basket_rebalance/
"""

from __future__ import annotations

import sys
from pathlib import Path

ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT))

from scripts.alerts import notify
from scripts.openalgo_client import default_strategy_tag, get_client
from scripts.responses import (
    available_cash, ensure_success, extract_ltp, extract_orderids_basket,
)
from scripts.trade_logger import open_journal

# ---- config --------------------------------------------------------------

TARGET_WEIGHTS = {     # symbol -> portfolio weight (must sum <= 1.0)
    "RELIANCE":   0.20,
    "TCS":        0.15,
    "INFY":       0.15,
    "HDFCBANK":   0.20,
    "ICICIBANK":  0.15,
    "SBIN":       0.15,
}
EXCHANGE = "NSE"
PRODUCT = "CNC"
TARGET_DEPLOYED_PCT = 90       # use 90% of available cash; keep 10% buffer

ALERTS = ("telegram",)

# ---- bootstrap -----------------------------------------------------------

client = get_client()
strategy = f"{default_strategy_tag()}_rebalance"
workdir = Path("openalgo_workspace/execution/basket_rebalance")
workdir.mkdir(parents=True, exist_ok=True)
journal = open_journal(workdir / "journal.csv")

# ---- 1. Current holdings -------------------------------------------------

holdings = client.holdings()
holdings_data = (holdings.get("data") or {}).get("holdings", []) if isinstance(holdings, dict) else []
current_qty = {h["symbol"].upper(): int(h["quantity"]) for h in holdings_data
               if h.get("exchange") == EXCHANGE and h.get("product") == PRODUCT}
print(f"Current holdings on {EXCHANGE}/{PRODUCT}: {current_qty}")

# ---- 2. Compute target rupee allocation ---------------------------------

cash = available_cash(client.funds())
holdings_value = sum(float(h.get("pnl", 0)) + float(h.get("quantity", 0)) * float(h.get("average_price", 0))
                     for h in holdings_data)
deployable = (cash + holdings_value) * TARGET_DEPLOYED_PCT / 100
print(f"Available cash: Rs {cash:,.2f}   estimated total: Rs {cash + holdings_value:,.2f}")
print(f"Deploying:      Rs {deployable:,.2f}")

# ---- 3. Build per-symbol orders -----------------------------------------

orders_to_place = []
for symbol, weight in TARGET_WEIGHTS.items():
    target_rs = deployable * weight
    quote = client.quotes(symbol=symbol, exchange=EXCHANGE)
    ltp = extract_ltp(quote)
    target_qty = int(target_rs // ltp)
    current = current_qty.get(symbol, 0)
    delta = target_qty - current

    print(f"  {symbol:<10} LTP {ltp:>8.2f}  current {current:>5d}  target {target_qty:>5d}  delta {delta:>+5d}")
    if delta == 0:
        continue

    orders_to_place.append({
        "symbol": symbol,
        "exchange": EXCHANGE,
        "action": "BUY" if delta > 0 else "SELL",
        "quantity": abs(delta),
        "pricetype": "MARKET",
        "product": PRODUCT,
    })
    journal.write(strategy=strategy, symbol=symbol, exchange=EXCHANGE,
                  action="BUY" if delta > 0 else "SELL", event="planned",
                  quantity=abs(delta), price=ltp)

# ---- 4. Confirm + place as a basket -------------------------------------

if not orders_to_place:
    print("\nPortfolio already at target weights. Nothing to do.")
    raise SystemExit()

print(f"\nPlacing {len(orders_to_place)} orders as a basket.")
if input("Confirm? [y/N] ").strip().lower() != "y":
    raise SystemExit("aborted")

resp = client.basketorder(orders=orders_to_place)
ensure_success(resp, action="basketorder")
success_ids = extract_orderids_basket(resp)
print(f"\n{len(success_ids)}/{len(orders_to_place)} legs placed successfully")

# ---- 5. Per-leg journal + alert -----------------------------------------

for leg, oid in zip(orders_to_place, success_ids):
    journal.write(strategy=strategy, symbol=leg["symbol"], exchange=EXCHANGE,
                  action=leg["action"], event="placed", order_id=oid,
                  quantity=leg["quantity"])

failed = [r for r in resp.get("results", []) if r.get("status") != "success"]
summary = (
    f"[REBALANCE COMPLETE]\n"
    f"Symbols changed: {len(orders_to_place)}\n"
    f"Legs filled OK:  {len(success_ids)}\n"
    f"Legs failed:     {len(failed)}\n"
    f"Deployed:        Rs {deployable:,.2f}"
)
notify(client, summary, via=ALERTS)
print("\n" + summary)
print(f"Journal: {workdir / 'journal.csv'}")

journal.close()

"""Place an iron condor via `optionsmultiorder` and verify each leg.

Iron condor: sell an OTM CE spread + sell an OTM PE spread. Net
short premium, defined risk on both sides.

Workflow:
1. Pre-flight: margin check via `client.margin`
2. Pre-flight: cash check vs. `client.funds`
3. Place 4 legs in one call via `optionsmultiorder`
4. Inspect `results[]` — each leg can independently fail
5. For each successfully placed leg, poll for fill and journal it
6. Send a WhatsApp summary

Output folder: openalgo_workspace/execution/iron_condor_nifty/
"""

from __future__ import annotations

import sys
from pathlib import Path

ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT))

from scripts.alerts import notify
from scripts.openalgo_client import default_strategy_tag, get_client
from scripts.responses import (
    avg_fill_price, available_cash, extract_orderids_basket,
    poll_until_filled, total_margin_required,
)
from scripts.trade_logger import open_journal

# ---- config --------------------------------------------------------------

UNDERLYING = "NIFTY"
UNDERLYING_EXCHANGE = "NSE_INDEX"
EXPIRY = "30JUN26"
QUANTITY = 75                     # 1 lot per leg

# Wing widths (offsets from ATM, in strikes)
SHORT_OFFSET = "OTM4"             # short call/put close to spot
LONG_OFFSET = "OTM6"              # long wings further out

ALERTS = ("telegram", "whatsapp")

# ---- bootstrap -----------------------------------------------------------

client = get_client()
strategy = f"{default_strategy_tag()}_iron_condor"

workdir = Path(f"openalgo_workspace/execution/iron_condor_{UNDERLYING.lower()}")
workdir.mkdir(parents=True, exist_ok=True)
journal = open_journal(workdir / "journal.csv")

# ---- 1 + 2. pre-flight margin + cash check -----------------------------

# Build the four legs
LEGS = [
    {"offset": LONG_OFFSET,  "option_type": "CE", "action": "BUY",  "quantity": QUANTITY},
    {"offset": LONG_OFFSET,  "option_type": "PE", "action": "BUY",  "quantity": QUANTITY},
    {"offset": SHORT_OFFSET, "option_type": "CE", "action": "SELL", "quantity": QUANTITY},
    {"offset": SHORT_OFFSET, "option_type": "PE", "action": "SELL", "quantity": QUANTITY},
]

# Margin calculator wants explicit symbols. Resolve via optionsymbol first.
priced_legs = []
for leg in LEGS:
    sym_resp = client.optionsymbol(
        underlying=UNDERLYING, exchange=UNDERLYING_EXCHANGE,
        expiry_date=EXPIRY, offset=leg["offset"], option_type=leg["option_type"],
    )
    priced_legs.append({
        "symbol": sym_resp["symbol"],
        "exchange": sym_resp["exchange"],
        "action": leg["action"],
        "product": "NRML",
        "pricetype": "MARKET",
        "quantity": str(leg["quantity"]),
    })

margin_resp = client.margin(positions=priced_legs)
margin_needed = total_margin_required(margin_resp)
cash = available_cash(client.funds())
print(f"Margin required: Rs {margin_needed:,.2f}")
print(f"Available cash:  Rs {cash:,.2f}")
if margin_needed > cash * 0.9:
    raise SystemExit(f"insufficient buffer: need Rs {margin_needed:,.2f}, have Rs {cash:,.2f}")

# ---- 3. Place the multi-leg order ---------------------------------------

print(f"\nPlacing iron condor: SELL {SHORT_OFFSET}, BUY {LONG_OFFSET}")
for leg in priced_legs:
    journal.write(strategy=strategy, symbol=leg["symbol"], exchange=leg["exchange"],
                  action=leg["action"], event="planned", quantity=int(leg["quantity"]))

resp = client.optionsmultiorder(
    strategy=strategy,
    underlying=UNDERLYING,
    exchange=UNDERLYING_EXCHANGE,
    expiry_date=EXPIRY,
    legs=LEGS,
)

# ---- 4 + 5. Per-leg verification ---------------------------------------

print(f"\nMulti-order response: status={resp.get('status')}, "
      f"underlying_ltp={resp.get('underlying_ltp')}")

success_legs = [r for r in resp.get("results", []) if r.get("status") == "success"]
failed_legs = [r for r in resp.get("results", []) if r.get("status") != "success"]

for leg in success_legs:
    print(f"  leg{leg.get('leg')} {leg.get('action')} {leg.get('symbol')} -> id {leg.get('orderid')}")
    journal.write(strategy=strategy, symbol=leg.get("symbol"), exchange="NFO",
                  action=leg.get("action"), event="placed",
                  order_id=leg.get("orderid"))

if failed_legs:
    print(f"\nWARNING: {len(failed_legs)} legs failed:")
    for f in failed_legs:
        print(f"  leg{f.get('leg')} {f.get('action')} -> {f.get('message')}")

# Poll each successful leg for fill
filled_premium = 0.0
for leg in success_legs:
    try:
        final = poll_until_filled(
            client, order_id=str(leg["orderid"]), strategy=strategy,
            interval_sec=1.0, timeout_sec=30.0,
        )
        px = avg_fill_price(final)
        signed = px * QUANTITY if leg["action"] == "SELL" else -px * QUANTITY
        filled_premium += signed
        journal.write(strategy=strategy, symbol=leg.get("symbol"), exchange="NFO",
                      action=leg.get("action"), event="filled",
                      order_id=leg.get("orderid"),
                      average_price=px, quantity=QUANTITY)
        print(f"    filled {leg['symbol']} @ Rs {px}")
    except Exception as exc:
        print(f"    {leg['symbol']} not filled within timeout: {exc}")

# ---- 6. Alert summary ---------------------------------------------------

summary = (
    f"[IRON CONDOR PLACED]\n"
    f"Underlying:  {UNDERLYING} {EXPIRY}\n"
    f"Short wing:  {SHORT_OFFSET}    Long wing: {LONG_OFFSET}\n"
    f"Legs placed: {len(success_legs)}/4   filled premium: Rs {filled_premium:,.2f}\n"
    f"Margin used: Rs {margin_needed:,.2f}"
)
notify(client, summary, via=ALERTS)
print("\n" + summary)
print(f"Journal: {workdir / 'journal.csv'}")
journal.close()

"""Place an entry order and chain SL + target based on the actual fill.

The canonical response-aware execution example. Uses
`scripts.workflows.place_with_sl_target` which internally:

    1. placeorder(MARKET or LIMIT)
    2. orderstatus(...) — poll until 'complete'
    3. read data.average_price from the fill
    4. compute SL  = fill * (1 - sl_pct/100)
       compute TGT = fill * (1 + target_pct/100)
    5. placeorder(SL-M, action=opposite, trigger_price=SL)
    6. placeorder(LIMIT, action=opposite, price=TGT)
    7. journal all three events + alert phone

Output folder: openalgo_workspace/execution/<symbol>_with_sl_target/
"""

from __future__ import annotations

import sys
from pathlib import Path

ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT))

from scripts.openalgo_client import default_strategy_tag, get_client
from scripts.trade_logger import open_journal
from scripts.workflows import place_with_sl_target

# ---- config --------------------------------------------------------------

SYMBOL = "SBIN"
EXCHANGE = "NSE"
ACTION = "BUY"
QUANTITY = 10
PRODUCT = "MIS"

SL_PCT = 1.0        # 1% below fill
TGT_PCT = 2.0       # 2% above fill (1:2 R/R)

ALERTS = ("telegram", "whatsapp")

# ---- bootstrap -----------------------------------------------------------

client = get_client()
strategy = default_strategy_tag()

workdir = Path(f"openalgo_workspace/execution/{SYMBOL.lower()}_with_sl_target")
workdir.mkdir(parents=True, exist_ok=True)
journal = open_journal(workdir / "journal.sqlite")

# ---- analyzer banner ----------------------------------------------------

mode = client.analyzerstatus().get("data", {}).get("mode", "unknown")
print(f"[{mode.upper()}]  {ACTION} {QUANTITY} {SYMBOL} @ {EXCHANGE}  "
      f"product={PRODUCT}  SL={SL_PCT}%  target={TGT_PCT}%")

if mode != "analyze":
    if input("Confirm LIVE entry with auto SL+target? [y/N] ").strip().lower() != "y":
        raise SystemExit("aborted")

# ---- execute ------------------------------------------------------------

result = place_with_sl_target(
    client,
    strategy=strategy,
    symbol=SYMBOL,
    exchange=EXCHANGE,
    action=ACTION,
    quantity=QUANTITY,
    product=PRODUCT,
    price_type="MARKET",
    sl_pct=SL_PCT,
    target_pct=TGT_PCT,
    fill_poll_interval_sec=0.5,
    fill_timeout_sec=30.0,
    journal=journal,
    alert_via=ALERTS,
)

# ---- summary -----------------------------------------------------------

print("\n--- Workflow result ---")
print(f"  Entry order: {result.entry_order_id}")
print(f"  Filled qty:  {result.entry_qty}")
print(f"  Fill price:  Rs {result.entry_avg_price}")
print(f"  SL order:    {result.sl_order_id}  trigger Rs {result.sl_trigger}")
print(f"  Target ord:  {result.target_order_id}  price Rs {result.target_price}")
print(f"  Journal:     {workdir / 'journal.sqlite'}")

journal.close()

"""Place a short ATM straddle on NIFTY with auto-SL on each leg.

Strategy: sell ATM CE + sell ATM PE for the same expiry. Profit if
NIFTY stays near the strike at expiry; loss if it moves either way
past the breakevens. The SL on each leg adapts to the *actual* fill
premium — not the intended quantity — using the response-aware
workflow `enter_options_atm_with_sl`.

Output folder: openalgo_workspace/execution/atm_straddle_nifty/
"""

from __future__ import annotations

import sys
from pathlib import Path

ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT))

from scripts.openalgo_client import default_strategy_tag, get_client
from scripts.responses import ResponseError
from scripts.trade_logger import open_journal
from scripts.workflows import enter_options_atm_with_sl

# ---- config --------------------------------------------------------------

UNDERLYING = "NIFTY"
UNDERLYING_EXCHANGE = "NSE_INDEX"
EXPIRY = "30JUN26"
QUANTITY = 75                  # 1 NIFTY lot at current SEBI lot size
PRODUCT = "NRML"

SL_PCT = 30.0                  # SL placed 30% above each filled premium
ALERTS = ("telegram", "whatsapp")

# ---- bootstrap -----------------------------------------------------------

client = get_client()
strategy = f"{default_strategy_tag()}_atm_straddle"

workdir = Path("openalgo_workspace/execution/atm_straddle_nifty")
workdir.mkdir(parents=True, exist_ok=True)
journal = open_journal(workdir / "journal.csv")

# ---- pre-flight: confirm analyzer or live mode --------------------------

mode_info = client.analyzerstatus().get("data", {})
banner = "[ANALYZER]" if mode_info.get("analyze_mode") else "[LIVE]"
print(f"{banner}  short ATM straddle on {UNDERLYING} {EXPIRY}  qty {QUANTITY} per leg")
if not mode_info.get("analyze_mode"):
    if input("Confirm LIVE placement? [y/N] ").strip().lower() != "y":
        raise SystemExit("aborted")

# ---- Leg 1: SELL ATM CE --------------------------------------------------

print("\n--- CE LEG ---")
try:
    ce_state = enter_options_atm_with_sl(
        client,
        underlying=UNDERLYING,
        underlying_exchange=UNDERLYING_EXCHANGE,
        expiry_date=EXPIRY,
        option_type="CE",
        offset="ATM",
        quantity=QUANTITY,
        product=PRODUCT,
        strategy=strategy + "_ce",
        sl_pct=SL_PCT,
        alert_via=ALERTS,
        journal=journal,
    )
    print(f"CE filled @ Rs {ce_state.entry_avg_price}   SL trigger Rs {ce_state.sl_trigger}")
except ResponseError as exc:
    print(f"CE LEG FAILED: {exc}")
    raise

# ---- Leg 2: SELL ATM PE --------------------------------------------------

print("\n--- PE LEG ---")
try:
    pe_state = enter_options_atm_with_sl(
        client,
        underlying=UNDERLYING,
        underlying_exchange=UNDERLYING_EXCHANGE,
        expiry_date=EXPIRY,
        option_type="PE",
        offset="ATM",
        quantity=QUANTITY,
        product=PRODUCT,
        strategy=strategy + "_pe",
        sl_pct=SL_PCT,
        alert_via=ALERTS,
        journal=journal,
    )
    print(f"PE filled @ Rs {pe_state.entry_avg_price}   SL trigger Rs {pe_state.sl_trigger}")
except ResponseError as exc:
    print(f"PE LEG FAILED: {exc}  -- consider cancelling CE leg manually")
    raise

# ---- Summary ------------------------------------------------------------

total_premium = (ce_state.entry_avg_price + pe_state.entry_avg_price) * QUANTITY
max_loss_proxy = total_premium * (SL_PCT / 100) * 2     # both SLs hit
print(f"\nStraddle entered.")
print(f"  premium collected: Rs {total_premium:,.2f}")
print(f"  worst-case (both SLs hit): Rs {max_loss_proxy:,.2f}")
print(f"  journal: {workdir / 'journal.csv'}")

journal.close()

"""Place a single equity LIMIT order with quote-anchored pricing.

Workflow:
1. Quote the symbol to get current LTP
2. Compute a marketable LIMIT a few ticks past LTP (safer than MARKET)
3. Show a preview, ask for confirmation
4. Place via place_with_retry (handles transient rate limits)
5. Print the resulting orderid

Output folder: openalgo_workspace/execution/place_equity_<SYMBOL>/
"""

from __future__ import annotations

import sys
from pathlib import Path

# Make scripts/ importable when running this file directly
ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT))

from scripts.openalgo_client import default_strategy_tag, get_client
from scripts.orders import OrderPreview, confirm_interactive, place_with_retry
from scripts.responses import extract_ltp, extract_orderid

# ---- config --------------------------------------------------------------

SYMBOL = "RELIANCE"
EXCHANGE = "NSE"
ACTION = "BUY"
QUANTITY = 1
PRODUCT = "MIS"               # MIS (intraday) | CNC (delivery)
SLIPPAGE_PCT = 0.15           # marketable-limit cushion past LTP

# ---- bootstrap -----------------------------------------------------------

client = get_client()
strategy = default_strategy_tag()

# ---- 1. Quote ------------------------------------------------------------

quote_resp = client.quotes(symbol=SYMBOL, exchange=EXCHANGE)
ltp = extract_ltp(quote_resp)
print(f"LTP {SYMBOL}@{EXCHANGE} = Rs {ltp}")

# ---- 2. Compute limit price ---------------------------------------------

if ACTION == "BUY":
    raw_price = ltp * (1 + SLIPPAGE_PCT / 100)
else:
    raw_price = ltp * (1 - SLIPPAGE_PCT / 100)
limit_price = round(raw_price * 20) / 20      # NSE tick = 0.05

# ---- 3. Preview + confirm -----------------------------------------------

preview = OrderPreview(
    strategy=strategy,
    symbol=SYMBOL,
    exchange=EXCHANGE,
    action=ACTION,
    quantity=QUANTITY,
    price_type="LIMIT",
    product=PRODUCT,
    price=limit_price,
    notional=limit_price * QUANTITY,
    note=f"LTP {ltp}; slippage cushion {SLIPPAGE_PCT}%",
)
if not confirm_interactive(preview):
    raise SystemExit("aborted by user")

# ---- 4. Place ------------------------------------------------------------

response = place_with_retry(
    client,
    strategy=strategy,
    symbol=SYMBOL,
    exchange=EXCHANGE,
    action=ACTION,
    price_type="LIMIT",
    product=PRODUCT,
    quantity=QUANTITY,
    price=limit_price,
)

# ---- 5. Read the response -----------------------------------------------

try:
    order_id = extract_orderid(response)
    print(f"\nORDER PLACED  id={order_id}  {ACTION} {QUANTITY} {SYMBOL} @ Rs {limit_price}")
except Exception as exc:
    print(f"\nORDER FAILED: {exc}\nRaw response: {response}")
    raise

"""Live Supertrend strategy on a single symbol.

Strategy:
- 5-minute bars
- Supertrend(10, 3.0) line + direction
- BUY when direction flips +1, SELL when it flips -1
- Position-aware: uses placesmartorder so the SDK reconciles current state

Workflow each tick (15 s sleep):
1. history(...) -> last 7 days of 5m bars
2. supertrend(...) -> latest direction
3. extract signal on the last fully closed bar (iloc[-2])
4. if signal flips, placesmartorder + alert

Output folder: openalgo_workspace/execution/supertrend_<SYMBOL>/
"""

from __future__ import annotations

import sys
import time
from datetime import datetime, timedelta
from pathlib import Path

import pandas as pd

ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT))

from scripts.alerts import notify
from scripts.openalgo_client import default_strategy_tag, get_client
from scripts.ta_helpers import supertrend
from scripts.trade_logger import open_journal

# ---- config --------------------------------------------------------------

SYMBOL = "RELIANCE"
EXCHANGE = "NSE"
PRODUCT = "MIS"
INTERVAL = "5m"
QUANTITY = 1

ATR_PERIOD = 10
ATR_MULT = 3.0

POLL_SECONDS = 15

ALERTS = ("telegram",)

# ---- bootstrap -----------------------------------------------------------

client = get_client()
strategy = f"{default_strategy_tag()}_supertrend"
workdir = Path(f"openalgo_workspace/execution/supertrend_{SYMBOL.lower()}")
workdir.mkdir(parents=True, exist_ok=True)
journal = open_journal(workdir / "journal.csv")

mode = client.analyzerstatus().get("data", {}).get("mode", "unknown")
print(f"[{mode.upper()}] Supertrend({ATR_PERIOD}, {ATR_MULT}) on {SYMBOL} {INTERVAL} {EXCHANGE}")

position = 0     # tracked locally; placesmartorder uses position_size to reconcile

# ---- main loop -----------------------------------------------------------

try:
    while True:
        try:
            end = datetime.now().strftime("%Y-%m-%d")
            start = (datetime.now() - timedelta(days=7)).strftime("%Y-%m-%d")

            df = client.history(symbol=SYMBOL, exchange=EXCHANGE,
                                interval=INTERVAL,
                                start_date=start, end_date=end)
            if df is None or len(df) < ATR_PERIOD + 2:
                print("not enough bars; sleeping")
                time.sleep(POLL_SECONDS)
                continue

            # Normalize timestamp index
            if "timestamp" in df.columns:
                df["timestamp"] = pd.to_datetime(df["timestamp"])
                df = df.set_index("timestamp")
            else:
                df.index = pd.to_datetime(df.index)
            if df.index.tz is not None:
                df.index = df.index.tz_convert(None)
            df = df.sort_index()

            # Compute supertrend
            st_line, st_dir = supertrend(df["high"], df["low"], df["close"],
                                          period=ATR_PERIOD, multiplier=ATR_MULT)
            # Signal on last fully-closed bar
            cur_dir = int(st_dir.iloc[-2])
            prev_dir = int(st_dir.iloc[-3])

            ltp = float(df["close"].iloc[-1])
            print(f"{df.index[-2].strftime('%H:%M')}  close={ltp}  "
                  f"st_line={st_line.iloc[-2]:.2f}  dir={cur_dir:+d}  pos={position}")

            # Detect flip and act
            if cur_dir > 0 and prev_dir <= 0 and position <= 0:
                position = QUANTITY
                resp = client.placesmartorder(
                    strategy=strategy, symbol=SYMBOL, exchange=EXCHANGE,
                    action="BUY", price_type="MARKET", product=PRODUCT,
                    quantity=QUANTITY, position_size=position,
                )
                journal.write(strategy=strategy, symbol=SYMBOL, exchange=EXCHANGE,
                              action="BUY", event="signal_flip_up",
                              price=ltp, quantity=QUANTITY,
                              order_id=str(resp.get("orderid", "")))
                notify(client, f"SUPERTREND BUY {SYMBOL} @ Rs {ltp}  qty {QUANTITY}", via=ALERTS)

            elif cur_dir < 0 and prev_dir >= 0 and position >= 0:
                position = -QUANTITY
                resp = client.placesmartorder(
                    strategy=strategy, symbol=SYMBOL, exchange=EXCHANGE,
                    action="SELL", price_type="MARKET", product=PRODUCT,
                    quantity=QUANTITY, position_size=position,
                )
                journal.write(strategy=strategy, symbol=SYMBOL, exchange=EXCHANGE,
                              action="SELL", event="signal_flip_down",
                              price=ltp, quantity=QUANTITY,
                              order_id=str(resp.get("orderid", "")))
                notify(client, f"SUPERTREND SELL {SYMBOL} @ Rs {ltp}  qty {QUANTITY}", via=ALERTS)

        except Exception as exc:
            print(f"[loop] {exc!r}")
            notify(client, f"Supertrend error: {exc}", via=ALERTS)

        time.sleep(POLL_SECONDS)

except KeyboardInterrupt:
    print("\nstopped by user")
    journal.close()

"""20-day breakout scanner across a universe.

For each symbol:
  1. Fetch daily history (60 days lookback)
  2. Compute 20-day rolling max of close (excluding today)
  3. Flag if current LTP > rolling max
  4. Compute breakout strength (% above resistance)
  5. Add volume confirmation (today's vol > 1.5x 20d avg)

Output folder: openalgo_workspace/scanners/breakout/
"""

from __future__ import annotations

import sys
from datetime import date
from pathlib import Path
from typing import Any

import pandas as pd

ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT))

from scripts.alerts import fmt_scanner_results, notify
from scripts.openalgo_client import get_client
from scripts.scanner import Scanner

UNIVERSE = [
    "RELIANCE", "TCS", "INFY", "HDFCBANK", "ICICIBANK", "SBIN", "BAJFINANCE",
    "BHARTIARTL", "ITC", "HINDUNILVR", "LT", "AXISBANK", "ASIANPAINT", "MARUTI",
    "TITAN", "ULTRACEMCO", "NESTLEIND", "WIPRO", "TECHM", "ADANIENT", "ADANIPORTS",
    "JSWSTEEL", "TATASTEEL", "HINDALCO", "COALINDIA", "ONGC", "NTPC", "POWERGRID",
]

LOOKBACK_DAYS = 60
BREAKOUT_WINDOW = 20
VOL_MULT = 1.5

client = get_client()


def enrich_breakout(symbol: str, exchange: str, df: pd.DataFrame) -> dict[str, Any]:
    """For one symbol's daily OHLCV history, compute breakout flags."""
    if len(df) < BREAKOUT_WINDOW + 1:
        return {"symbol": symbol, "exchange": exchange, "skip": "insufficient_history"}

    close = df["close"]
    high = df["high"]
    volume = df["volume"]

    # Resistance = max close over previous N bars (excluding today)
    resistance = high.iloc[:-1].rolling(BREAKOUT_WINDOW).max().iloc[-1]
    today_high = high.iloc[-1]
    today_close = close.iloc[-1]
    avg_vol_20 = volume.iloc[:-1].rolling(BREAKOUT_WINDOW).mean().iloc[-1]
    today_vol = volume.iloc[-1]

    breakout = today_close > resistance and today_high > resistance
    vol_confirm = avg_vol_20 > 0 and today_vol >= avg_vol_20 * VOL_MULT

    return {
        "symbol":        symbol,
        "exchange":      exchange,
        "today_close":   round(float(today_close), 2),
        "resistance":    round(float(resistance), 2),
        "breakout_pct":  round(float((today_close / resistance - 1) * 100), 2),
        "today_vol":     int(today_vol),
        "avg_vol_20":    int(avg_vol_20) if pd.notna(avg_vol_20) else 0,
        "vol_x":         round(float(today_vol / avg_vol_20), 2) if avg_vol_20 else 0.0,
        "breakout":      bool(breakout),
        "vol_confirm":   bool(vol_confirm),
    }


# ---- Run scan -----------------------------------------------------------

print(f"Scanning {len(UNIVERSE)} symbols for {BREAKOUT_WINDOW}-day breakout + volume confirmation")
df = (
    Scanner(client)
    .add_many(UNIVERSE, exchange="NSE")
    .history_scan(
        interval="D",
        lookback_days=LOOKBACK_DAYS,
        enrich=enrich_breakout,
        max_workers=6,
    )
)

# Filter to confirmed breakouts
hits = df[(df.get("breakout", False)) & (df.get("vol_confirm", False))].copy()
hits = hits.sort_values("breakout_pct", ascending=False).reset_index(drop=True)

print(f"\n{len(hits)} confirmed breakouts:")
if not hits.empty:
    print(hits[["symbol", "today_close", "resistance", "breakout_pct", "vol_x"]].to_string(index=False))

# ---- Persist + alert ----------------------------------------------------

workdir = Path("openalgo_workspace/scanners/breakout")
workdir.mkdir(parents=True, exist_ok=True)
today = date.today().isoformat()
df.to_csv(workdir / f"all_{today}.csv", index=False)
hits.to_csv(workdir / f"hits_{today}.csv", index=False)

if not hits.empty:
    summary = fmt_scanner_results(
        f"{BREAKOUT_WINDOW}-Day Breakout + Volume Confirm",
        hits.head(10).to_dict("records"),
        fields=["symbol", "today_close", "resistance", "breakout_pct", "vol_x"],
        max_rows=10,
    )
    notify(client, summary, via=("telegram",))
    print("\n" + summary)

print(f"\nSaved to {workdir}")

"""Top gainers and top losers in NIFTY 50 via `multiquotes`.

Single REST call returns LTP + prev_close for all 50 constituents.
Sorted by % change. Writes CSVs and optionally alerts the top 5.

Output folder: openalgo_workspace/scanners/nifty50_gainers_losers/
"""

from __future__ import annotations

import sys
from datetime import date
from pathlib import Path

ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT))

from scripts.alerts import fmt_scanner_results, notify
from scripts.openalgo_client import get_client
from scripts.scanner import Scanner, gainers, losers

NIFTY50 = [
    "ADANIENT", "ADANIPORTS", "APOLLOHOSP", "ASIANPAINT", "AXISBANK", "BAJAJ-AUTO",
    "BAJFINANCE", "BAJAJFINSV", "BEL", "BHARTIARTL", "CIPLA", "COALINDIA", "DRREDDY",
    "EICHERMOT", "ETERNAL", "GRASIM", "HCLTECH", "HDFCBANK", "HDFCLIFE", "HEROMOTOCO",
    "HINDALCO", "HINDUNILVR", "ICICIBANK", "INDUSINDBK", "INFY", "ITC", "JIOFIN",
    "JSWSTEEL", "KOTAKBANK", "LT", "M&M", "MARUTI", "NESTLEIND", "NTPC", "ONGC",
    "POWERGRID", "RELIANCE", "SBILIFE", "SBIN", "SHRIRAMFIN", "SUNPHARMA", "TATACONSUM",
    "TATAMOTORS", "TATASTEEL", "TCS", "TECHM", "TITAN", "TRENT", "ULTRACEMCO", "WIPRO",
]

ALERT_TOP = 5
ALERTS = ("telegram",)

client = get_client()

# ---- Gainers ------------------------------------------------------------

print("Running scan: gainers >= 1%")
gainers_df = (
    Scanner(client)
    .add_many(NIFTY50, exchange="NSE")
    .with_filter(gainers(threshold_pct=1.0))
    .quote_scan()
)
gainers_df = gainers_df.head(15).reset_index(drop=True)
print(gainers_df[["symbol", "ltp", "prev_close", "pct_change", "volume"]])

# ---- Losers -------------------------------------------------------------

print("\nRunning scan: losers <= -1%")
losers_df = (
    Scanner(client)
    .add_many(NIFTY50, exchange="NSE")
    .with_filter(losers(threshold_pct=1.0))
    .quote_scan()
)
losers_df = losers_df.head(15).reset_index(drop=True)
print(losers_df[["symbol", "ltp", "prev_close", "pct_change", "volume"]])

# ---- Persist + alert ----------------------------------------------------

workdir = Path("openalgo_workspace/scanners/nifty50_gainers_losers")
workdir.mkdir(parents=True, exist_ok=True)

today = date.today().isoformat()
gainers_df.to_csv(workdir / f"gainers_{today}.csv", index=False)
losers_df.to_csv(workdir / f"losers_{today}.csv", index=False)

summary_top_gainers = fmt_scanner_results(
    f"NIFTY 50 Top Gainers ({today})",
    gainers_df.head(ALERT_TOP).to_dict("records"),
    fields=["symbol", "ltp", "pct_change"],
    max_rows=ALERT_TOP,
)
summary_top_losers = fmt_scanner_results(
    f"NIFTY 50 Top Losers ({today})",
    losers_df.head(ALERT_TOP).to_dict("records"),
    fields=["symbol", "ltp", "pct_change"],
    max_rows=ALERT_TOP,
)

notify(client, summary_top_gainers + "\n\n" + summary_top_losers, via=ALERTS)
print(f"\nSaved to {workdir}")

"""Pre-open gap scanner — flags symbols with significant gap up/down at open.

Run this within the first 5 minutes of the session. Compares today's
open to yesterday's close.

Workflow:
  1. multiquotes -> ltp, open, prev_close for the universe
  2. compute gap = (open / prev_close - 1) * 100
  3. flag |gap| >= threshold
  4. sort and alert

Output folder: openalgo_workspace/scanners/pre_open_gap/
"""

from __future__ import annotations

import sys
from datetime import date
from pathlib import Path

ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT))

from scripts.alerts import fmt_scanner_results, notify
from scripts.openalgo_client import get_client
from scripts.scanner import Scanner, gap_up, gap_down

UNIVERSE = [
    "RELIANCE", "TCS", "INFY", "HDFCBANK", "ICICIBANK", "SBIN", "BAJFINANCE",
    "BHARTIARTL", "ITC", "HINDUNILVR", "LT", "AXISBANK", "ASIANPAINT", "MARUTI",
    "TITAN", "ULTRACEMCO", "NESTLEIND", "WIPRO", "TECHM", "ADANIENT", "ADANIPORTS",
    "JSWSTEEL", "TATASTEEL", "HINDALCO", "COALINDIA", "ONGC", "NTPC", "POWERGRID",
    "TATAMOTORS", "M&M", "EICHERMOT", "HEROMOTOCO", "BAJAJ-AUTO",
]

GAP_THRESHOLD_PCT = 1.5

client = get_client()

# ---- Gap up scan --------------------------------------------------------

up = (
    Scanner(client)
    .add_many(UNIVERSE, exchange="NSE")
    .with_filter(gap_up(min_pct=GAP_THRESHOLD_PCT))
    .quote_scan()
)
print(f"\nGap UP >= {GAP_THRESHOLD_PCT}%   ({len(up)} symbols)")
if not up.empty:
    print(up[["symbol", "open", "prev_close", "gap_pct", "ltp"]].to_string(index=False))

# ---- Gap down scan ------------------------------------------------------

down = (
    Scanner(client)
    .add_many(UNIVERSE, exchange="NSE")
    .with_filter(gap_down(min_pct=GAP_THRESHOLD_PCT))
    .quote_scan()
)
print(f"\nGap DOWN >= {GAP_THRESHOLD_PCT}%   ({len(down)} symbols)")
if not down.empty:
    print(down[["symbol", "open", "prev_close", "gap_pct", "ltp"]].to_string(index=False))

# ---- Persist + alert ----------------------------------------------------

workdir = Path("openalgo_workspace/scanners/pre_open_gap")
workdir.mkdir(parents=True, exist_ok=True)
today = date.today().isoformat()

up.to_csv(workdir / f"gap_up_{today}.csv", index=False)
down.to_csv(workdir / f"gap_down_{today}.csv", index=False)

if not up.empty or not down.empty:
    msg = ""
    if not up.empty:
        msg += fmt_scanner_results(
            f"Gap UP >= {GAP_THRESHOLD_PCT}%",
            up.head(10).to_dict("records"),
            fields=["symbol", "open", "prev_close", "gap_pct"], max_rows=10,
        )
    if not down.empty:
        if msg:
            msg += "\n\n"
        msg += fmt_scanner_results(
            f"Gap DOWN >= {GAP_THRESHOLD_PCT}%",
            down.head(10).to_dict("records"),
            fields=["symbol", "open", "prev_close", "gap_pct"], max_rows=10,
        )
    notify(client, msg, via=("telegram",))

print(f"\nSaved to {workdir}")

"""RSI oversold scanner — finds stocks with RSI(14) <= 30.

Daily timeframe. Useful for mean-reversion setups and dip-buying.

Output folder: openalgo_workspace/scanners/rsi_oversold/
"""

from __future__ import annotations

import sys
from datetime import date
from pathlib import Path
from typing import Any

import pandas as pd
import talib as tl

ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT))

from scripts.alerts import fmt_scanner_results, notify
from scripts.openalgo_client import get_client
from scripts.scanner import Scanner

UNIVERSE = [
    "RELIANCE", "TCS", "INFY", "HDFCBANK", "ICICIBANK", "SBIN", "BAJFINANCE",
    "BHARTIARTL", "ITC", "HINDUNILVR", "LT", "AXISBANK", "ASIANPAINT", "MARUTI",
    "TITAN", "ULTRACEMCO", "NESTLEIND", "WIPRO", "TECHM", "ADANIENT", "ADANIPORTS",
    "JSWSTEEL", "TATASTEEL", "HINDALCO", "COALINDIA", "ONGC", "NTPC", "POWERGRID",
    "TATAMOTORS", "M&M", "EICHERMOT", "HEROMOTOCO", "BAJAJ-AUTO",
]

RSI_PERIOD = 14
OVERSOLD_THRESHOLD = 30
BEAR_TREND_FILTER = True   # only flag if 50DMA is below 200DMA (downtrending mean revert)

client = get_client()


def enrich_rsi(symbol: str, exchange: str, df: pd.DataFrame) -> dict[str, Any]:
    if len(df) < 220:
        return {"symbol": symbol, "exchange": exchange, "skip": "need_220_bars"}
    close = df["close"]
    rsi = pd.Series(tl.RSI(close.values, timeperiod=RSI_PERIOD), index=close.index)
    sma50 = pd.Series(tl.SMA(close.values, timeperiod=50), index=close.index)
    sma200 = pd.Series(tl.SMA(close.values, timeperiod=200), index=close.index)

    return {
        "symbol":  symbol,
        "ltp":     round(float(close.iloc[-1]), 2),
        "rsi":     round(float(rsi.iloc[-1]), 2),
        "rsi_5d_min": round(float(rsi.iloc[-5:].min()), 2),
        "sma50":   round(float(sma50.iloc[-1]), 2),
        "sma200":  round(float(sma200.iloc[-1]), 2),
        "trend":   "down" if sma50.iloc[-1] < sma200.iloc[-1] else "up",
    }


# ---- Scan ---------------------------------------------------------------

print(f"Scanning {len(UNIVERSE)} symbols for RSI({RSI_PERIOD}) <= {OVERSOLD_THRESHOLD}")
df = (
    Scanner(client)
    .add_many(UNIVERSE, exchange="NSE")
    .history_scan(interval="D", lookback_days=400, enrich=enrich_rsi, max_workers=6)
)
df = df[df.get("skip").isna() if "skip" in df.columns else True]

oversold = df[df["rsi"] <= OVERSOLD_THRESHOLD].copy()
if BEAR_TREND_FILTER:
    oversold = oversold[oversold["trend"] == "down"]

oversold = oversold.sort_values("rsi").reset_index(drop=True)
print(f"\n{len(oversold)} oversold matches:")
if not oversold.empty:
    print(oversold[["symbol", "ltp", "rsi", "rsi_5d_min", "sma50", "sma200", "trend"]].to_string(index=False))

# ---- Persist + alert ----------------------------------------------------

workdir = Path("openalgo_workspace/scanners/rsi_oversold")
workdir.mkdir(parents=True, exist_ok=True)
today = date.today().isoformat()
df.to_csv(workdir / f"all_{today}.csv", index=False)
oversold.to_csv(workdir / f"oversold_{today}.csv", index=False)

if not oversold.empty:
    notify(
        client,
        fmt_scanner_results(
            f"RSI({RSI_PERIOD}) <= {OVERSOLD_THRESHOLD}",
            oversold.head(10).to_dict("records"),
            fields=["symbol", "ltp", "rsi"], max_rows=10,
        ),
        via=("telegram",),
    )

print(f"\nSaved to {workdir}")

"""Volume-surge scanner — symbols trading at > N x their 20-day average.

For each symbol:
  1. Pull 30 days of daily history
  2. Compute 20-day average volume (excluding today)
  3. Flag if today's volume >= average * threshold
  4. Optional: filter to symbols making new 20d high

Output folder: openalgo_workspace/scanners/volume_surge/
"""

from __future__ import annotations

import sys
from datetime import date
from pathlib import Path
from typing import Any

import pandas as pd

ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT))

from scripts.alerts import fmt_scanner_results, notify
from scripts.openalgo_client import get_client
from scripts.scanner import Scanner

UNIVERSE = [
    "RELIANCE", "TCS", "INFY", "HDFCBANK", "ICICIBANK", "SBIN", "BAJFINANCE",
    "BHARTIARTL", "ITC", "HINDUNILVR", "LT", "AXISBANK", "ASIANPAINT", "MARUTI",
    "TITAN", "ULTRACEMCO", "NESTLEIND", "WIPRO", "TECHM", "ADANIENT", "ADANIPORTS",
    "JSWSTEEL", "TATASTEEL", "HINDALCO", "COALINDIA", "ONGC", "NTPC", "POWERGRID",
]

VOLUME_MULTIPLIER = 3.0
AVG_PERIOD = 20
REQUIRE_NEW_HIGH = False

client = get_client()


def enrich_volume(symbol: str, exchange: str, df: pd.DataFrame) -> dict[str, Any]:
    if len(df) < AVG_PERIOD + 1:
        return {"symbol": symbol, "exchange": exchange, "skip": "need_history"}
    avg = df["volume"].iloc[-AVG_PERIOD - 1:-1].mean()
    today_vol = df["volume"].iloc[-1]
    today_close = df["close"].iloc[-1]
    new_high = today_close >= df["high"].iloc[-AVG_PERIOD - 1:-1].max()
    return {
        "symbol": symbol,
        "ltp":     round(float(today_close), 2),
        "today_vol":  int(today_vol),
        "avg_vol":    int(avg) if pd.notna(avg) else 0,
        "vol_x":      round(float(today_vol / avg), 2) if avg else 0.0,
        "pct_change": round(float((today_close / df["close"].iloc[-2] - 1) * 100), 2)
                      if len(df) > 1 else 0.0,
        "new_high":   bool(new_high),
    }


# ---- Scan ---------------------------------------------------------------

print(f"Scanning {len(UNIVERSE)} symbols for vol >= {VOLUME_MULTIPLIER}x 20-day avg")
df = (
    Scanner(client)
    .add_many(UNIVERSE, exchange="NSE")
    .history_scan(interval="D", lookback_days=AVG_PERIOD + 10,
                  enrich=enrich_volume, max_workers=6)
)

hits = df[df.get("vol_x", 0) >= VOLUME_MULTIPLIER].copy()
if REQUIRE_NEW_HIGH:
    hits = hits[hits["new_high"]]
hits = hits.sort_values("vol_x", ascending=False).reset_index(drop=True)

print(f"\n{len(hits)} surge matches:")
if not hits.empty:
    print(hits[["symbol", "ltp", "pct_change", "vol_x", "new_high"]].to_string(index=False))

# ---- Persist + alert ---------------------------------------------------

workdir = Path("openalgo_workspace/scanners/volume_surge")
workdir.mkdir(parents=True, exist_ok=True)
today = date.today().isoformat()
df.to_csv(workdir / f"all_{today}.csv", index=False)
hits.to_csv(workdir / f"hits_{today}.csv", index=False)

if not hits.empty:
    notify(
        client,
        fmt_scanner_results(
            f"Volume surge >= {VOLUME_MULTIPLIER}x 20d avg",
            hits.head(10).to_dict("records"),
            fields=["symbol", "ltp", "pct_change", "vol_x", "new_high"], max_rows=10,
        ),
        via=("telegram",),
    )

print(f"\nSaved to {workdir}")

"""Side-by-side CE / PE Open Interest histogram for an option chain.

Output folder: openalgo_workspace/visualization/oi_histogram_<UNDERLYING>_<EXPIRY>/
"""

from __future__ import annotations

import sys
from datetime import date
from pathlib import Path

ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT))

from scripts.openalgo_client import get_client
from scripts.option_analytics import chain_to_df, pcr, max_pain
from scripts.plotting import oi_histogram

# ---- config ------------------------------------------------------------

UNDERLYING = "NIFTY"
UNDERLYING_EXCHANGE = "NSE_INDEX"
EXPIRY = "30JUN26"
STRIKE_COUNT = 30           # 30 strikes either side of ATM
STRIKE_FILTER = 100         # filter to round strikes (NIFTY 100-point grid)

client = get_client()

# ---- Fetch chain --------------------------------------------------------

print(f"Fetching {UNDERLYING} {EXPIRY} option chain (±{STRIKE_COUNT} strikes around ATM)")
chain_resp = client.optionchain(
    underlying=UNDERLYING,
    exchange=UNDERLYING_EXCHANGE,
    expiry_date=EXPIRY,
    strike_count=STRIKE_COUNT,
)
df = chain_to_df(chain_resp)
print(f"  underlying: {df.attrs['underlying']} @ {df.attrs['underlying_ltp']}")
print(f"  ATM strike: {df.attrs['atm_strike']}")
print(f"  strikes:    {len(df['strike'].unique())}")

# Filter to round strikes only (no 50-point in-between)
if STRIKE_FILTER:
    df = df[df["strike"] % STRIKE_FILTER == 0].copy()
    print(f"  after {STRIKE_FILTER}-point filter: {len(df['strike'].unique())} strikes")

# ---- Compute PCR + max-pain --------------------------------------------

pcr_oi = pcr(df, basis="oi")
pcr_vol = pcr(df, basis="volume")
mp = max_pain(df)
print(f"\n  PCR (OI):     {pcr_oi:.2f}")
print(f"  PCR (volume): {pcr_vol:.2f}")
print(f"  Max pain:     {mp['strike']:.0f}")

# ---- Plot --------------------------------------------------------------

workdir = Path(f"openalgo_workspace/visualization/oi_histogram_{UNDERLYING.lower()}_{EXPIRY.lower()}")
workdir.mkdir(parents=True, exist_ok=True)
out = workdir / f"oi_{date.today()}.html"

oi_histogram(
    df,
    title=f"{UNDERLYING} {EXPIRY} — OI Histogram   "
          f"PCR(OI)={pcr_oi:.2f}  MaxPain={mp['strike']:.0f}  "
          f"Spot={df.attrs['underlying_ltp']}",
    out=out,
)

# Also save the raw chain data
df.to_csv(workdir / f"chain_{date.today()}.csv", index=False)
print(f"\nSaved: {out}")

"""Put-Call Ratio dashboard across multiple underlyings.

For each underlying-expiry combination:
  1. Fetch option chain
  2. Compute PCR(OI) and PCR(volume)
  3. Render a comparison bar chart

Output folder: openalgo_workspace/visualization/pcr_dashboard/
"""

from __future__ import annotations

import sys
from datetime import date
from pathlib import Path

import pandas as pd
import plotly.graph_objects as go

ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT))

from scripts.openalgo_client import get_client
from scripts.option_analytics import chain_to_df, pcr

UNDERLYINGS = [
    ("NIFTY", "NSE_INDEX"),
    ("BANKNIFTY", "NSE_INDEX"),
    ("FINNIFTY", "NSE_INDEX"),
    ("MIDCPNIFTY", "NSE_INDEX"),
]
EXPIRY = "30JUN26"
STRIKE_COUNT = 30

client = get_client()

rows = []
for underlying, exch in UNDERLYINGS:
    try:
        resp = client.optionchain(
            underlying=underlying, exchange=exch,
            expiry_date=EXPIRY, strike_count=STRIKE_COUNT,
        )
        df = chain_to_df(resp)
        rows.append({
            "underlying": underlying,
            "spot":       df.attrs["underlying_ltp"],
            "atm":        df.attrs["atm_strike"],
            "pcr_oi":     round(pcr(df, basis="oi"), 3),
            "pcr_volume": round(pcr(df, basis="volume"), 3),
            "n_strikes":  len(df["strike"].unique()),
        })
        print(f"  {underlying:<12} spot={df.attrs['underlying_ltp']}  "
              f"PCR(OI)={rows[-1]['pcr_oi']:.2f}  "
              f"PCR(vol)={rows[-1]['pcr_volume']:.2f}")
    except Exception as exc:
        print(f"  {underlying:<12} ERROR: {exc}")
        continue

dashboard = pd.DataFrame(rows)

# ---- Bar chart ---------------------------------------------------------

fig = go.Figure([
    go.Bar(name="PCR (OI)",     x=dashboard["underlying"], y=dashboard["pcr_oi"],
           marker_color="#42a5f5"),
    go.Bar(name="PCR (volume)", x=dashboard["underlying"], y=dashboard["pcr_volume"],
           marker_color="#ef5350"),
])
fig.add_hline(y=1.0, line_dash="dash", line_color="white",
              annotation_text="Neutral PCR = 1.0", annotation_position="top right")
fig.update_layout(
    title=f"Put-Call Ratio Dashboard — {EXPIRY} expiry — {date.today()}",
    template="plotly_dark", height=550, barmode="group",
    xaxis_title="Underlying", yaxis_title="PCR",
)

# ---- Save -------------------------------------------------------------

workdir = Path("openalgo_workspace/visualization/pcr_dashboard")
workdir.mkdir(parents=True, exist_ok=True)
out = workdir / f"pcr_{date.today()}.html"
fig.write_html(str(out), include_plotlyjs="cdn")
dashboard.to_csv(workdir / f"data_{date.today()}.csv", index=False)
print(f"\nSaved: {out}")
fig.show()