Seasonal & Calendar Strategies

# Foundation: pull years of NIFTY daily candles and add a daily-return column.
import os
from datetime import datetime, timedelta

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

end = datetime.now().strftime("%Y-%m-%d")
start = (datetime.now() - timedelta(days=900)).strftime("%Y-%m-%d")

df = client.history(symbol="NIFTY", exchange="NSE_INDEX", interval="D", start_date=start, end_date=end)

# Daily return = today's close vs yesterday's close, as a percentage.
df["ret"] = df["close"].pct_change() * 100

print("Trading days loaded:", len(df))
print("Date range:", df.index.min().date(), "to", df.index.max().date())
print("\nLast 3 days with returns:")
print(df[["close", "ret"]].tail(3).round(2))

# Day-of-week seasonality: which weekday has historically paid the most?
import os
from datetime import datetime, timedelta

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

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

df["ret"] = df["close"].pct_change() * 100
df = df.dropna(subset=["ret"])
# index.dayofweek: Monday=0 ... Friday=4. Keep regular weekdays, group, average.
df = df[df.index.dayofweek < 5]
names = {0: "Mon", 1: "Tue", 2: "Wed", 3: "Thu", 4: "Fri"}
by_day = df.groupby(df.index.dayofweek)["ret"].agg(["mean", "count"])
by_day.index = by_day.index.map(names)

print("Average NIFTY return by weekday (%):")
print(by_day.round(3))
print("\nBest weekday on average:", by_day["mean"].idxmax())

# Month-of-year seasonality: roll daily returns up into a return for each month.
import os
from datetime import datetime, timedelta

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

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

# Resample to month-end and compute each calendar month's total return (%).
monthly = df["close"].resample("ME").last().pct_change() * 100
# Group those monthly returns by their month number (1..12) and average.
names = {1: "Jan", 2: "Feb", 3: "Mar", 4: "Apr", 5: "May", 6: "Jun",
         7: "Jul", 8: "Aug", 9: "Sep", 10: "Oct", 11: "Nov", 12: "Dec"}
by_month = monthly.groupby(monthly.index.month).mean()
by_month.index = by_month.index.map(names)

print("Average NIFTY return by calendar month (%):")
print(by_month.round(2))
print("\nHistorically strongest month:", by_month.idxmax())
print("Historically weakest month:  ", by_month.idxmin())

# Turn-of-month effect: are the last + first few trading days unusually strong?
import os
from datetime import datetime, timedelta

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

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

df["ret"] = df["close"].pct_change() * 100
# Rank each trading day inside its own month: 1, 2, 3 ... from the start.
month_key = df.index.to_period("M")
df["dom_rank"] = df.groupby(month_key).cumcount() + 1          # day-of-month rank
df["from_end"] = df.groupby(month_key).cumcount(ascending=False)  # 0 = last day

# Turn-of-month window = last 2 days of a month OR first 3 days of the next.
tom = (df["from_end"] <= 1) | (df["dom_rank"] <= 3)

print("Turn-of-month days :", int(tom.sum()))
print("Other days         :", int((~tom).sum()))
print("Avg return on turn-of-month days (%):", round(df.loc[tom, "ret"].mean(), 3))
print("Avg return on all other days     (%):", round(df.loc[~tom, "ret"].mean(), 3))

# Boolean calendar masks: a True/False filter you can AND/OR like a trading rule.
import os
from datetime import datetime, timedelta

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

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

df["ret"] = df["close"].pct_change() * 100

# Each mask is a column of True/False, one per trading day.
is_monday = df.index.dayofweek == 0
is_friday = df.index.dayofweek == 4
is_q4 = df.index.month >= 10            # Oct, Nov, Dec

# Combine masks with & (and) / | (or) to express a precise calendar rule.
friday_in_q4 = is_friday & is_q4

print("Mondays in data :", int(is_monday.sum()), "| avg ret %:", round(df.loc[is_monday, "ret"].mean(), 3))
print("Fridays in data :", int(is_friday.sum()), "| avg ret %:", round(df.loc[is_friday, "ret"].mean(), 3))
print("Fridays in Q4   :", int(friday_in_q4.sum()), "| avg ret %:", round(df.loc[friday_in_q4, "ret"].mean(), 3))

# Expiry-week behaviour: discover the weekly expiry weekday, then test its returns.
import os
from datetime import datetime, timedelta

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

# Discover the weekday weekly options expire on -- never hard-code it.
expiries = client.expiry(symbol="NIFTY", exchange="NFO", instrumenttype="options")["data"]
near = [datetime.strptime(d, "%d-%b-%y") for d in expiries[:4]]
expiry_dow = max({d.weekday() for d in near}, key=[d.weekday() for d in near].count)
dow_name = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"][expiry_dow]
print("Weekly NIFTY options expire on:", dow_name, f"(weekday {expiry_dow})")

end = datetime.now().strftime("%Y-%m-%d")
start = (datetime.now() - timedelta(days=900)).strftime("%Y-%m-%d")
df = client.history(symbol="NIFTY", exchange="NSE_INDEX", interval="D", start_date=start, end_date=end)
df["ret"] = df["close"].pct_change() * 100

on_expiry = df.index.dayofweek == expiry_dow
print(f"\nAvg return on expiry day ({dow_name}) %:", round(df.loc[on_expiry, "ret"].mean(), 3))
print("Avg return on all other days       %:", round(df.loc[~on_expiry, "ret"].mean(), 3))
print("Expiry-day win rate                %:", round((df.loc[on_expiry, "ret"] > 0).mean() * 100, 1))

# Backtest a seasonal rule: be long ONLY on historically strong weekdays.
import os
from datetime import datetime, timedelta

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

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

df["ret"] = df["close"].pct_change().fillna(0)
# Step 1: learn which weekdays were positive on average.
strong = df.groupby(df.index.dayofweek)["ret"].mean()
strong_days = strong[strong > 0].index.tolist()
names = {0: "Mon", 1: "Tue", 2: "Wed", 3: "Thu", 4: "Fri"}
print("Strong weekdays (held):", [names[d] for d in strong_days])

# Step 2: the rule earns the day's return only when that weekday is "strong".
in_market = df.index.dayofweek.isin(strong_days)
df["strategy"] = df["ret"].where(in_market, 0.0)

# Step 3: compound both equity curves from a notional 100.
buy_hold = (1 + df["ret"]).cumprod() * 100
seasonal = (1 + df["strategy"]).cumprod() * 100
print("\nBuy & hold final value :", round(buy_hold.iloc[-1], 1))
print("Seasonal rule final    :", round(seasonal.iloc[-1], 1))
print("Days in market         :", int(in_market.sum()), "of", len(df))

# Visualise seasonality: a year x month grid of NIFTY monthly returns.
import os
from datetime import datetime, timedelta
from pathlib import Path

import matplotlib.pyplot as plt
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"),
)

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

monthly = df["close"].resample("ME").last().pct_change() * 100
grid = monthly.groupby([monthly.index.year, monthly.index.month]).mean().unstack()

fig, ax = plt.subplots(figsize=(9, 3.5))
im = ax.imshow(grid.values, cmap="RdYlGn", aspect="auto", vmin=-8, vmax=8)
ax.set_xticks(range(len(grid.columns)))
ax.set_xticklabels(["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"][:len(grid.columns)])
ax.set_yticks(range(len(grid.index)))
ax.set_yticklabels(grid.index)
ax.set_title("NIFTY monthly return (%) by year")
fig.colorbar(im, ax=ax, label="% return")

out = Path(__file__).with_suffix(".png")
plt.savefig(out, dpi=110, bbox_inches="tight")
print("Saved", out.name)
print(grid.round(1))