Cash & Equity Strategies

# The golden cross: 50-day SMA crossing above the 200-day SMA. A classic trend filter.
import os
from datetime import datetime, timedelta

from openalgo import api, ta

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

# 200-day SMA needs a long history -- ~400 calendar days gives plenty of bars.
end = datetime.now().strftime("%Y-%m-%d")
start = (datetime.now() - timedelta(days=400)).strftime("%Y-%m-%d")
df = client.history(symbol="RELIANCE", exchange="NSE", interval="D", start_date=start, end_date=end)

close = df["close"]
sma50 = ta.sma(close, 50)
sma200 = ta.sma(close, 200)

regime = "BULLISH (golden cross)" if sma50.iloc[-1] > sma200.iloc[-1] else "BEARISH (death cross)"
print("Latest close :", round(float(close.iloc[-1]), 2))
print("SMA50  :", round(float(sma50.iloc[-1]), 2))
print("SMA200 :", round(float(sma200.iloc[-1]), 2))
print("Current regime:", regime)

# Turn the golden/death cross into dated entry and exit signals.
import os
from datetime import datetime, timedelta

import pandas as pd
from openalgo import api, ta

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

end = datetime.now().strftime("%Y-%m-%d")
start = (datetime.now() - timedelta(days=600)).strftime("%Y-%m-%d")
df = client.history(symbol="HDFCBANK", exchange="NSE", interval="D", start_date=start, end_date=end)

close = df["close"]
sma50, sma200 = ta.sma(close, 50), ta.sma(close, 200)

golden = pd.Series(ta.crossover(sma50, sma200), index=df.index)   # 50 crosses above 200 -> buy
death = pd.Series(ta.crossunder(sma50, sma200), index=df.index)   # 50 crosses below 200 -> exit

print("Golden crosses:", int(golden.sum()), "| Death crosses:", int(death.sum()))
events = pd.DataFrame({"close": close, "golden": golden, "death": death})
print(events[golden | death].tail(6))

# A quick equity-curve preview from signals -- no VectorBT yet (that's Chapter 26).
import os
from datetime import datetime, timedelta

import pandas as pd
from openalgo import api, ta

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

end = datetime.now().strftime("%Y-%m-%d")
start = (datetime.now() - timedelta(days=400)).strftime("%Y-%m-%d")
df = client.history(symbol="ICICIBANK", exchange="NSE", interval="D", start_date=start, end_date=end)

close = df["close"]
# A 20/50 EMA cross trades more often than 50/200 -- handy for showing a real curve.
fast, slow = ta.ema(close, 20), ta.ema(close, 50)
buy = pd.Series(ta.crossover(fast, slow), index=df.index)
sell = pd.Series(ta.crossunder(fast, slow), index=df.index)

# Hold a long while flip() is on; shift(1) so we earn TOMORROW's return, not today's.
position = pd.Series(ta.flip(buy, sell), index=df.index).astype(int)
daily_ret = close.pct_change().fillna(0)
strat_ret = daily_ret * position.shift(1).fillna(0)

strat_curve = (1 + strat_ret).cumprod()
buyhold_curve = (1 + daily_ret).cumprod()
print("Strategy   total return: {:.1f}%".format((strat_curve.iloc[-1] - 1) * 100))
print("Buy & hold total return: {:.1f}%".format((buyhold_curve.iloc[-1] - 1) * 100))
print("Days in the market:", int(position.sum()), "of", len(position))
print("Final equity on 1.0 start:", round(float(strat_curve.iloc[-1]), 3))

# Momentum ranking: sort a universe by N-day return and buy the leaders.
import os
from datetime import datetime, timedelta

import pandas as pd
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"),
)

universe = ["RELIANCE", "TCS", "INFY", "HDFCBANK", "ICICIBANK", "SBIN",
            "AXISBANK", "WIPRO", "ITC", "LT", "MARUTI", "KOTAKBANK"]

end = datetime.now().strftime("%Y-%m-%d")
start = (datetime.now() - timedelta(days=120)).strftime("%Y-%m-%d")
LOOKBACK = 60  # trading-bar momentum window


def daily(sym):
    df = client.history(symbol=sym, exchange="NSE", interval="D", start_date=start, end_date=end)
    return df if isinstance(df, pd.DataFrame) and not df.empty else None


rows = []
for sym in universe:
    df = daily(sym)
    if df is None or len(df) <= LOOKBACK:
        continue
    close = df["close"]
    mom = (close.iloc[-1] / close.iloc[-1 - LOOKBACK] - 1) * 100
    rows.append({"symbol": sym, "momentum_%": round(float(mom), 2)})

ranked = pd.DataFrame(rows).sort_values("momentum_%", ascending=False).reset_index(drop=True)
ranked.index += 1
print(f"Ranked by {LOOKBACK}-bar momentum. A rotation would hold the top 3:")
print(ranked.to_string())
print("\nTop 3 to hold this month:", list(ranked["symbol"].head(3)))

# Donchian channel breakout: buy a close above the 20-day high, exit below the 20-day low.
import os
from datetime import datetime, timedelta

import numpy as np
from openalgo import api, ta

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

end = datetime.now().strftime("%Y-%m-%d")
start = (datetime.now() - timedelta(days=200)).strftime("%Y-%m-%d")
df = client.history(symbol="INFY", exchange="NSE", interval="D", start_date=start, end_date=end)

# donchian returns three Series: upper (highest high), middle, lower (lowest low).
upper, middle, lower = ta.donchian(df["high"], df["low"], period=20)

close = df["close"].iloc[-1]
# Compare to the channel as it stood YESTERDAY ([-2]) so today's bar can break it.
upper_prev = np.asarray(upper)[-2]
lower_prev = np.asarray(lower)[-2]

print("Latest close :", round(float(close), 2))
print("20-day upper (prior bar):", round(float(upper_prev), 2))
print("20-day lower (prior bar):", round(float(lower_prev), 2))
if close > upper_prev:
    print("Signal: BREAKOUT -- close cleared the 20-day high.")
elif close < lower_prev:
    print("Signal: BREAKDOWN -- close broke the 20-day low.")
else:
    print("Signal: inside the channel -- no trade.")

# A full Donchian system: hold a long between breakout and breakdown, preview the curve.
import os
from datetime import datetime, timedelta

import pandas as pd
from openalgo import api, ta

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

end = datetime.now().strftime("%Y-%m-%d")
start = (datetime.now() - timedelta(days=400)).strftime("%Y-%m-%d")
df = client.history(symbol="LT", exchange="NSE", interval="D", start_date=start, end_date=end)

close = df["close"]
upper, _, lower = ta.donchian(df["high"], df["low"], period=20)
upper = pd.Series(upper, index=df.index)
lower = pd.Series(lower, index=df.index)

# Enter when close clears the prior upper band; exit when it loses the prior lower band.
buy = close > upper.shift(1)
sell = close < lower.shift(1)
position = pd.Series(ta.flip(buy, sell), index=df.index).astype(int)

ret = close.pct_change().fillna(0)
strat = ret * position.shift(1).fillna(0)
print("Trades opened:", int((position.diff() == 1).sum()))
print("Days held    :", int(position.sum()), "of", len(position))
print("Strategy total return: {:.1f}%".format(((1 + strat).cumprod().iloc[-1] - 1) * 100))
print("Buy & hold   total return: {:.1f}%".format(((1 + ret).cumprod().iloc[-1] - 1) * 100))

# Delivery equity strategies use the CNC product. Here is how CNC and MIS differ.
import os

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"),
)

product_notes = {
    "CNC": "Cash & Carry -- delivery. Shares settle into your demat; hold for days, weeks or years.",
    "MIS": "Margin Intraday Square-off -- auto-closed the same session; for day trades only.",
    "NRML": "Normal -- the carry product for F&O positions held overnight.",
}

print("Equity strategy products at a glance:")
for code, note in product_notes.items():
    print(f"  {code:5s} {note}")

print("\nA golden-cross trade may hold for months, so it MUST use product='CNC'.")
print("Using 'MIS' would square off the position automatically at the close -- wrong tool.")

# Acting on a signal: place a delivery (CNC) buy. Safe to run -- server is in analyze mode.
import os
from datetime import datetime, timedelta

from openalgo import api, ta

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

# Re-check the regime, then only buy if the golden cross is in force.
end = datetime.now().strftime("%Y-%m-%d")
start = (datetime.now() - timedelta(days=400)).strftime("%Y-%m-%d")
df = client.history(symbol="SBIN", exchange="NSE", interval="D", start_date=start, end_date=end)
close = df["close"]
bullish = ta.sma(close, 50).iloc[-1] > ta.sma(close, 200).iloc[-1]

if bullish:
    resp = client.placeorder(
        strategy="GoldenCross",
        symbol="SBIN",
        action="BUY",
        exchange="NSE",
        price_type="MARKET",
        product="CNC",   # delivery -- this is a multi-week hold
        quantity=1,
    )
    print("Regime bullish -- placed CNC buy:", resp.get("status"), resp.get("orderid"))
else:
    print("Regime not bullish -- staying flat, no order placed.")