Indicator Expert

"""
Bollinger Bands Chart — with squeeze detection and %B subplot
"""
import os
from datetime import datetime, timedelta
from pathlib import Path

import pandas as pd
import plotly.graph_objects as go
from plotly.subplots import make_subplots
from dotenv import find_dotenv, load_dotenv
from openalgo import api, ta

script_dir = Path(__file__).resolve().parent
load_dotenv(find_dotenv(), override=False)

SYMBOL = "SBIN"
EXCHANGE = "NSE"
INTERVAL = "D"
BB_PERIOD = 20
BB_STD = 2.0

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

end_date = datetime.now().date()
start_date = end_date - timedelta(days=365)

df = client.history(
    symbol=SYMBOL, exchange=EXCHANGE, interval=INTERVAL,
    start_date=start_date.strftime("%Y-%m-%d"),
    end_date=end_date.strftime("%Y-%m-%d"),
)
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)
df = df.sort_index()
if df.index.tz is not None:
    df.index = df.index.tz_convert(None)

close = df["close"]
upper, middle, lower = ta.bbands(close, BB_PERIOD, BB_STD)
bb_pct = ta.bb_percent(close, BB_PERIOD, BB_STD)
bb_width = ta.bb_width(close, BB_PERIOD, BB_STD)

x_labels = df.index.strftime("%Y-%m-%d")

fig = make_subplots(
    rows=3, cols=1, shared_xaxes=True,
    row_heights=[0.55, 0.22, 0.23], vertical_spacing=0.03,
    subplot_titles=[
        f"{SYMBOL} Price + Bollinger Bands({BB_PERIOD}, {BB_STD})",
        f"Bollinger %B",
        f"Bollinger Width (Squeeze Detection)",
    ],
)

# Candlestick + Bands
fig.add_trace(go.Scatter(
    x=x_labels, y=upper, mode="lines", name="Upper BB",
    line=dict(color="rgba(100,149,237,0.6)", width=1),
), row=1, col=1)
fig.add_trace(go.Scatter(
    x=x_labels, y=lower, mode="lines", name="Lower BB",
    line=dict(color="rgba(100,149,237,0.6)", width=1),
    fill="tonexty", fillcolor="rgba(100,149,237,0.08)",
), row=1, col=1)
fig.add_trace(go.Scatter(
    x=x_labels, y=middle, mode="lines", name=f"SMA({BB_PERIOD})",
    line=dict(color="cornflowerblue", width=1, dash="dash"),
), row=1, col=1)
fig.add_trace(go.Candlestick(
    x=x_labels, open=df["open"], high=df["high"], low=df["low"], close=close,
    name="Price",
), row=1, col=1)

# %B
fig.add_trace(go.Scatter(
    x=x_labels, y=bb_pct, mode="lines",
    name="%B", line=dict(color="yellow", width=1.5),
), row=2, col=1)
fig.add_hline(y=1.0, line_dash="dash", line_color="red", opacity=0.5, row=2, col=1)
fig.add_hline(y=0.0, line_dash="dash", line_color="green", opacity=0.5, row=2, col=1)
fig.add_hline(y=0.5, line_dash="dot", line_color="gray", opacity=0.3, row=2, col=1)

# Width (squeeze)
fig.add_trace(go.Scatter(
    x=x_labels, y=bb_width, mode="lines",
    name="BB Width", line=dict(color="cyan", width=1.5),
), row=3, col=1)

fig.update_layout(
    template="plotly_dark",
    title=f"{SYMBOL} — Bollinger Bands Analysis",
    xaxis_rangeslider_visible=False,
    height=900,
)
for r in range(1, 4):
    fig.update_xaxes(type="category", row=r, col=1)
    fig.update_yaxes(side="right", row=r, col=1)

fig.write_html(script_dir / f"{SYMBOL}_bollinger_chart.html")
fig.show()

# Explanation
current_pct = bb_pct.iloc[-1]
current_width = bb_width.iloc[-1]
min_width = pd.Series(bb_width).rolling(20).min().iloc[-1]

if current_pct > 1:
    position = "ABOVE upper band — overbought / breakout"
elif current_pct < 0:
    position = "BELOW lower band — oversold / breakdown"
elif current_pct > 0.8:
    position = "Near upper band — approaching resistance"
elif current_pct < 0.2:
    position = "Near lower band — approaching support"
else:
    position = "Inside bands — range-bound"

squeeze = "YES — volatility squeeze" if current_width <= min_width * 1.05 else "No"

print(f"\n{SYMBOL} — Bollinger Bands({BB_PERIOD}, {BB_STD}) Analysis")
print(f"Upper: {upper.iloc[-1]:.2f} | Middle: {middle.iloc[-1]:.2f} | Lower: {lower.iloc[-1]:.2f}")
print(f"%B: {current_pct:.4f}")
print(f"Position: {position}")
print(f"Band Width: {current_width:.4f}")
print(f"Squeeze: {squeeze}")

"""
Custom Indicator Template — Z-Score Example
Demonstrates the pattern for building custom indicators on top of openalgo's
Rust-core primitives (openalgo.ta) with vectorized NumPy.

No JIT, no warmup: openalgo 2.x computes ta primitives in a compiled Rust core,
so the first call already runs at full speed.

Usage:
    from zscore_indicator import zscore
    result = zscore(close_prices, period=20)
"""
import numpy as np
import pandas as pd
from openalgo import ta


# =============================================================================
# Core Computation — vectorized NumPy on Rust-core primitives
# =============================================================================

def _compute_zscore(arr: np.ndarray, period: int) -> np.ndarray:
    """
    Z-Score: (value - rolling_mean) / rolling_stdev

    Measures how many standard deviations the current value is from the mean.
    - Z > 2: Extremely high (potential overbought)
    - Z > 1: Above average
    - Z ~ 0: At average
    - Z < -1: Below average
    - Z < -2: Extremely low (potential oversold)

    Complexity: O(n) — ta.sma and ta.stdev run in the Rust core.
    """
    n = len(arr)
    result = np.full(n, np.nan)
    if period < 2 or n < period:
        return result

    mean = ta.sma(arr, period)
    std = ta.stdev(arr, period)

    valid = ~np.isnan(mean) & ~np.isnan(std)
    nonzero = valid & (std > 0)
    result[nonzero] = (arr[nonzero] - mean[nonzero]) / std[nonzero]
    result[valid & (std == 0)] = 0.0
    return result


def _compute_zscore_bands(arr: np.ndarray, period: int,
                          upper_threshold: float,
                          lower_threshold: float):
    """
    Z-Score with upper/lower price bands for signal generation.
    Returns: (zscore, upper_band, lower_band, mean_line)
    """
    n = len(arr)
    zscore_vals = np.full(n, np.nan)
    upper_band = np.full(n, np.nan)
    lower_band = np.full(n, np.nan)
    mean_line = np.full(n, np.nan)
    if period < 2 or n < period:
        return zscore_vals, upper_band, lower_band, mean_line

    mean = ta.sma(arr, period)
    std = ta.stdev(arr, period)

    valid = ~np.isnan(mean) & ~np.isnan(std)
    mean_line[valid] = mean[valid]
    upper_band[valid] = mean[valid] + upper_threshold * std[valid]
    lower_band[valid] = mean[valid] + lower_threshold * std[valid]

    nonzero = valid & (std > 0)
    zscore_vals[nonzero] = (arr[nonzero] - mean[nonzero]) / std[nonzero]
    zscore_vals[valid & (std == 0)] = 0.0
    return zscore_vals, upper_band, lower_band, mean_line


# =============================================================================
# Public API — Handles pandas/numpy/list input
# =============================================================================

def zscore(data, period=20):
    """
    Z-Score Indicator

    Measures how many standard deviations the current price is from its
    rolling mean. Useful for mean-reversion strategies.

    Args:
        data: Close prices (numpy array, pandas Series, or list)
        period: Lookback period (default: 20)

    Returns:
        Z-Score values (same type as input)
    """
    if isinstance(data, pd.Series):
        idx = data.index
        result = _compute_zscore(data.values.astype(np.float64), period)
        return pd.Series(result, index=idx, name=f"ZScore({period})")

    arr = np.asarray(data, dtype=np.float64)
    return _compute_zscore(arr, period)


def zscore_bands(data, period=20, upper=2.0, lower=-2.0):
    """
    Z-Score with price bands.

    Args:
        data: Close prices
        period: Lookback period (default: 20)
        upper: Upper threshold in stdev units (default: 2.0)
        lower: Lower threshold in stdev units (default: -2.0)

    Returns:
        Tuple: (zscore, upper_band, lower_band, mean_line)
    """
    if isinstance(data, pd.Series):
        idx = data.index
        z, ub, lb, ml = _compute_zscore_bands(
            data.values.astype(np.float64), period, upper, lower)
        return (
            pd.Series(z, index=idx, name=f"ZScore({period})"),
            pd.Series(ub, index=idx, name="Upper"),
            pd.Series(lb, index=idx, name="Lower"),
            pd.Series(ml, index=idx, name="Mean"),
        )

    arr = np.asarray(data, dtype=np.float64)
    return _compute_zscore_bands(arr, period, upper, lower)


# =============================================================================
# Benchmark — no warmup needed, first call is full speed
# =============================================================================

if __name__ == "__main__":
    import time

    print("Z-Score Indicator Benchmark")
    print("-" * 40)

    for size in [10_000, 100_000, 500_000]:
        data = np.random.randn(size).cumsum() + 1000

        t0 = time.perf_counter()
        _ = zscore(data, 20)
        elapsed = (time.perf_counter() - t0) * 1000
        print(f"  zscore({size:>10,} bars): {elapsed:>8.2f}ms")

        t0 = time.perf_counter()
        _ = zscore_bands(data, 20)
        elapsed = (time.perf_counter() - t0) * 1000
        print(f"  bands ({size:>10,} bars): {elapsed:>8.2f}ms")

"""
Basic Indicator Dashboard — Single symbol with configurable indicators
Run: python app.py
Open: http://127.0.0.1:8050
"""
import os
from datetime import datetime, timedelta

import numpy as np
import pandas as pd
import plotly.graph_objects as go
from plotly.subplots import make_subplots
import dash
from dash import dcc, html, Input, Output, callback, State
import dash_bootstrap_components as dbc
from dotenv import find_dotenv, load_dotenv
from openalgo import api, ta

load_dotenv(find_dotenv(), override=False)

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


def fetch_data(symbol, exchange, interval, days=365):
    end_date = datetime.now().date()
    start_date = end_date - timedelta(days=days)
    df = client.history(
        symbol=symbol, exchange=exchange, interval=interval,
        start_date=start_date.strftime("%Y-%m-%d"),
        end_date=end_date.strftime("%Y-%m-%d"),
    )
    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)
    df = df.sort_index()
    if df.index.tz is not None:
        df.index = df.index.tz_convert(None)
    return df


app = dash.Dash(__name__, external_stylesheets=[dbc.themes.DARKLY])

app.layout = dbc.Container([
    dbc.Row([
        dbc.Col(html.H3("OpenAlgo Indicator Dashboard"), width=8),
    ], className="mb-3 mt-3"),

    dbc.Row([
        dbc.Col([
            dbc.Label("Symbol"),
            dbc.Input(id="symbol-input", value="SBIN", type="text"),
        ], width=2),
        dbc.Col([
            dbc.Label("Exchange"),
            dbc.Select(id="exchange-select", value="NSE",
                       options=[{"label": e, "value": e}
                                for e in ["NSE", "BSE", "NFO", "NSE_INDEX", "MCX"]]),
        ], width=2),
        dbc.Col([
            dbc.Label("Interval"),
            dbc.Select(id="interval-select", value="D",
                       options=[{"label": i, "value": i}
                                for i in ["1m", "5m", "15m", "30m", "1h", "D"]]),
        ], width=2),
        dbc.Col([
            dbc.Label("Overlays"),
            dbc.Checklist(
                id="overlay-select",
                options=[
                    {"label": " EMA(20)", "value": "ema20"},
                    {"label": " EMA(50)", "value": "ema50"},
                    {"label": " Bollinger", "value": "bbands"},
                    {"label": " Supertrend", "value": "supertrend"},
                ],
                value=["ema20"],
                inline=True,
            ),
        ], width=3),
        dbc.Col([
            dbc.Button("Load", id="load-btn", color="primary", className="mt-4"),
        ], width=1),
    ], className="mb-3"),

    dbc.Row([
        dbc.Col([
            dbc.Label("Subplots"),
            dbc.Checklist(
                id="subplot-select",
                options=[
                    {"label": " RSI", "value": "rsi"},
                    {"label": " MACD", "value": "macd"},
                    {"label": " Volume", "value": "volume"},
                    {"label": " Stochastic", "value": "stochastic"},
                    {"label": " ADX", "value": "adx"},
                    {"label": " OBV", "value": "obv"},
                ],
                value=["rsi", "volume"],
                inline=True,
            ),
        ], width=12),
    ], className="mb-3"),

    dbc.Row(id="stats-row", className="mb-3"),
    dbc.Row([dbc.Col(dcc.Graph(id="main-chart"), width=12)]),
    dcc.Interval(id="refresh-interval", interval=60_000, n_intervals=0),
], fluid=True)


@callback(
    Output("main-chart", "figure"),
    Output("stats-row", "children"),
    Input("load-btn", "n_clicks"),
    State("symbol-input", "value"),
    State("exchange-select", "value"),
    State("interval-select", "value"),
    State("overlay-select", "value"),
    State("subplot-select", "value"),
    prevent_initial_call=False,
)
def update_chart(n_clicks, symbol, exchange, interval, overlays, subplots):
    days_map = {"1m": 7, "5m": 30, "15m": 90, "30m": 90, "1h": 180, "D": 365}
    days = days_map.get(interval, 365)

    df = fetch_data(symbol, exchange, interval, days)
    close = df["close"]
    high = df["high"]
    low = df["low"]

    if not overlays:
        overlays = []
    if not subplots:
        subplots = []

    n_rows = 1 + len(subplots)
    heights = [0.5] + [0.5 / max(len(subplots), 1)] * len(subplots) if subplots else [1.0]
    titles = [f"{symbol} ({exchange})"] + [s.upper() for s in subplots]

    fig = make_subplots(
        rows=n_rows, cols=1, shared_xaxes=True,
        row_heights=heights, vertical_spacing=0.03,
        subplot_titles=titles,
    )

    fmt = "%Y-%m-%d" if interval == "D" else "%Y-%m-%d %H:%M"
    x_labels = df.index.strftime(fmt)

    # Candlestick
    fig.add_trace(go.Candlestick(
        x=x_labels, open=df["open"], high=high, low=low, close=close,
        name="Price", showlegend=False,
    ), row=1, col=1)

    # Overlays
    if "ema20" in overlays:
        fig.add_trace(go.Scatter(x=x_labels, y=ta.ema(close, 20),
                                 name="EMA(20)", line=dict(color="cyan", width=1.5)),
                      row=1, col=1)
    if "ema50" in overlays:
        fig.add_trace(go.Scatter(x=x_labels, y=ta.ema(close, 50),
                                 name="EMA(50)", line=dict(color="orange", width=1.5)),
                      row=1, col=1)
    if "bbands" in overlays:
        upper, mid, lower = ta.bbands(close, 20, 2.0)
        fig.add_trace(go.Scatter(x=x_labels, y=upper, name="BB Upper",
                                 line=dict(color="gray", dash="dash", width=1)), row=1, col=1)
        fig.add_trace(go.Scatter(x=x_labels, y=lower, name="BB Lower",
                                 line=dict(color="gray", dash="dash", width=1),
                                 fill="tonexty", fillcolor="rgba(128,128,128,0.08)"),
                      row=1, col=1)
    if "supertrend" in overlays:
        st, direction = ta.supertrend(high, low, close, 10, 3.0)
        st_up = pd.Series(st, index=df.index).where(pd.Series(direction, index=df.index) == -1)
        st_down = pd.Series(st, index=df.index).where(pd.Series(direction, index=df.index) == 1)
        fig.add_trace(go.Scatter(x=x_labels, y=st_up, name="ST Up",
                                 line=dict(color="lime", width=2)), row=1, col=1)
        fig.add_trace(go.Scatter(x=x_labels, y=st_down, name="ST Down",
                                 line=dict(color="red", width=2)), row=1, col=1)

    # Subplots
    for i, sp in enumerate(subplots, start=2):
        if sp == "rsi":
            fig.add_trace(go.Scatter(x=x_labels, y=ta.rsi(close, 14),
                                     name="RSI(14)", line=dict(color="yellow", width=1.5)),
                          row=i, col=1)
            fig.add_hline(y=70, line_dash="dash", line_color="red", opacity=0.5, row=i, col=1)
            fig.add_hline(y=30, line_dash="dash", line_color="green", opacity=0.5, row=i, col=1)
            fig.update_yaxes(range=[0, 100], row=i, col=1)
        elif sp == "macd":
            m, s, h = ta.macd(close, 12, 26, 9)
            fig.add_trace(go.Scatter(x=x_labels, y=m, name="MACD",
                                     line=dict(color="cyan", width=1)), row=i, col=1)
            fig.add_trace(go.Scatter(x=x_labels, y=s, name="Signal",
                                     line=dict(color="orange", width=1)), row=i, col=1)
            colors = ["green" if v >= 0 else "red" for v in h]
            fig.add_trace(go.Bar(x=x_labels, y=h, name="Hist",
                                 marker_color=colors, opacity=0.6), row=i, col=1)
        elif sp == "volume":
            vc = ["green" if c >= o else "red" for c, o in zip(close, df["open"])]
            fig.add_trace(go.Bar(x=x_labels, y=df["volume"], name="Volume",
                                 marker_color=vc, opacity=0.5), row=i, col=1)
        elif sp == "stochastic":
            k, d = ta.stochastic(high, low, close, k_period=14, smooth_k=3, d_period=3)
            fig.add_trace(go.Scatter(x=x_labels, y=k, name="%K",
                                     line=dict(color="cyan", width=1)), row=i, col=1)
            fig.add_trace(go.Scatter(x=x_labels, y=d, name="%D",
                                     line=dict(color="orange", width=1)), row=i, col=1)
            fig.add_hline(y=80, line_dash="dash", line_color="red", opacity=0.5, row=i, col=1)
            fig.add_hline(y=20, line_dash="dash", line_color="green", opacity=0.5, row=i, col=1)
        elif sp == "adx":
            dp, dm, adx = ta.adx(high, low, close, 14)
            fig.add_trace(go.Scatter(x=x_labels, y=dp, name="+DI",
                                     line=dict(color="lime", width=1)), row=i, col=1)
            fig.add_trace(go.Scatter(x=x_labels, y=dm, name="-DI",
                                     line=dict(color="red", width=1)), row=i, col=1)
            fig.add_trace(go.Scatter(x=x_labels, y=adx, name="ADX",
                                     line=dict(color="yellow", width=1.5)), row=i, col=1)
            fig.add_hline(y=25, line_dash="dash", line_color="gray", opacity=0.5, row=i, col=1)
        elif sp == "obv":
            fig.add_trace(go.Scatter(x=x_labels, y=ta.obv(close, df["volume"]),
                                     name="OBV", line=dict(color="cyan", width=1.5)),
                          row=i, col=1)

    fig.update_layout(
        template="plotly_dark", height=250 + 220 * n_rows,
        xaxis_rangeslider_visible=False,
    )
    for r in range(1, n_rows + 1):
        fig.update_xaxes(type="category", row=r, col=1)
        fig.update_yaxes(side="right", row=r, col=1)

    # Stats cards
    try:
        quote = client.quotes(symbol=symbol, exchange=exchange)
        d = quote.get("data", {})
        ltp = d.get("ltp", close.iloc[-1])
        prev = d.get("prev_close", close.iloc[-2] if len(close) > 1 else ltp)
    except Exception:
        ltp = close.iloc[-1]
        prev = close.iloc[-2] if len(close) > 1 else ltp

    change = ltp - prev
    change_pct = (change / prev * 100) if prev != 0 else 0
    rsi_val = ta.rsi(close, 14).iloc[-1] if len(close) > 14 else 0

    cards = [
        ("LTP", f"{ltp:,.2f}", "primary"),
        ("Change", f"{change:+,.2f} ({change_pct:+.2f}%)", "success" if change >= 0 else "danger"),
        ("RSI(14)", f"{rsi_val:.1f}", "warning" if rsi_val > 70 or rsi_val < 30 else "info"),
        ("Volume", f"{df['volume'].iloc[-1]:,.0f}", "secondary"),
        ("EMA(20)", f"{ta.ema(close, 20).iloc[-1]:,.2f}", "info"),
    ]

    stat_cards = [
        dbc.Col(dbc.Card(dbc.CardBody([
            html.P(label, className="text-muted mb-0", style={"fontSize": "0.75rem"}),
            html.H5(value, className="mb-0"),
        ]), color=color, outline=True), width=2)
        for label, value, color in cards
    ]

    return fig, stat_cards


if __name__ == "__main__":
    app.run(debug=True, port=8050)

"""
Multi-Timeframe Dashboard — Same symbol across 4 timeframes
Run: python app.py
Open: http://127.0.0.1:8050
"""
import os
from datetime import datetime, timedelta

import numpy as np
import pandas as pd
import plotly.graph_objects as go
from plotly.subplots import make_subplots
import dash
from dash import dcc, html, Input, Output, State, callback
import dash_bootstrap_components as dbc
from dotenv import find_dotenv, load_dotenv
from openalgo import api, ta

load_dotenv(find_dotenv(), override=False)

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

TIMEFRAMES = {
    "5m": {"interval": "5m", "days": 7, "fmt": "%H:%M"},
    "15m": {"interval": "15m", "days": 30, "fmt": "%m-%d %H:%M"},
    "1h": {"interval": "1h", "days": 90, "fmt": "%m-%d %H:%M"},
    "D": {"interval": "D", "days": 365, "fmt": "%Y-%m-%d"},
}


def fetch_tf_data(symbol, exchange, interval, days):
    end_date = datetime.now().date()
    start_date = end_date - timedelta(days=days)
    df = client.history(
        symbol=symbol, exchange=exchange, interval=interval,
        start_date=start_date.strftime("%Y-%m-%d"),
        end_date=end_date.strftime("%Y-%m-%d"),
    )
    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)
    df = df.sort_index()
    if df.index.tz is not None:
        df.index = df.index.tz_convert(None)
    return df


app = dash.Dash(__name__, external_stylesheets=[dbc.themes.DARKLY])

app.layout = dbc.Container([
    dbc.Row([
        dbc.Col(html.H3("Multi-Timeframe Analysis"), width=6),
        dbc.Col([
            dbc.InputGroup([
                dbc.Input(id="symbol-input", value="SBIN", placeholder="Symbol"),
                dbc.Select(id="exchange-select", value="NSE",
                           options=[{"label": e, "value": e}
                                    for e in ["NSE", "BSE", "NFO", "NSE_INDEX"]]),
                dbc.Button("Load", id="load-btn", color="primary"),
            ]),
        ], width=6),
    ], className="mb-3 mt-3"),

    dbc.Row(id="confluence-row", className="mb-3"),
    dbc.Row([dbc.Col(dcc.Graph(id="mtf-chart"), width=12)]),
], fluid=True)


@callback(
    Output("mtf-chart", "figure"),
    Output("confluence-row", "children"),
    Input("load-btn", "n_clicks"),
    State("symbol-input", "value"),
    State("exchange-select", "value"),
    prevent_initial_call=False,
)
def update_mtf(n_clicks, symbol, exchange):
    fig = make_subplots(
        rows=2, cols=2,
        subplot_titles=[f"{symbol} — {tf}" for tf in TIMEFRAMES],
        vertical_spacing=0.08, horizontal_spacing=0.05,
    )

    trends = {}
    for idx, (tf_name, tf_cfg) in enumerate(TIMEFRAMES.items()):
        row = idx // 2 + 1
        col = idx % 2 + 1

        try:
            df = fetch_tf_data(symbol, exchange, tf_cfg["interval"], tf_cfg["days"])
        except Exception:
            continue

        close = df["close"]
        x = df.index.strftime(tf_cfg["fmt"])

        fig.add_trace(go.Candlestick(
            x=x, open=df["open"], high=df["high"], low=df["low"], close=close,
            name=tf_name, showlegend=False,
        ), row=row, col=col)

        ema_20 = ta.ema(close, 20)
        ema_50 = ta.ema(close, min(50, len(close) - 1)) if len(close) > 50 else ema_20

        fig.add_trace(go.Scatter(x=x, y=ema_20, mode="lines",
                                 name=f"EMA20 {tf_name}", line=dict(color="cyan", width=1),
                                 showlegend=False), row=row, col=col)
        fig.add_trace(go.Scatter(x=x, y=ema_50, mode="lines",
                                 name=f"EMA50 {tf_name}", line=dict(color="orange", width=1),
                                 showlegend=False), row=row, col=col)

        fig.update_xaxes(type="category", row=row, col=col)
        fig.update_xaxes(rangeslider_visible=False, row=row, col=col)
        fig.update_yaxes(side="right", row=row, col=col)

        # Determine trend
        if len(close) > 20:
            rsi_val = ta.rsi(close, 14).iloc[-1] if len(close) > 14 else 50
            ema_trend = "bullish" if ema_20.iloc[-1] > ema_50.iloc[-1] else "bearish"
            trends[tf_name] = {"trend": ema_trend, "rsi": rsi_val}

    fig.update_layout(
        template="plotly_dark", height=800,
        title=f"{symbol} Multi-Timeframe Analysis",
        showlegend=False,
    )

    # Confluence cards
    bull_count = sum(1 for v in trends.values() if v["trend"] == "bullish")
    total = len(trends)

    if bull_count == total and total > 0:
        confluence = "STRONG BULLISH — All timeframes aligned"
        color = "success"
    elif bull_count == 0 and total > 0:
        confluence = "STRONG BEARISH — All timeframes aligned"
        color = "danger"
    else:
        confluence = f"MIXED — {bull_count}/{total} bullish"
        color = "warning"

    cards = [dbc.Col(dbc.Alert(confluence, color=color), width=4)]
    for tf, data in trends.items():
        c = "success" if data["trend"] == "bullish" else "danger"
        cards.append(dbc.Col(dbc.Card(dbc.CardBody([
            html.P(tf, className="text-muted mb-0"),
            html.H6(f"{data['trend'].upper()} | RSI: {data['rsi']:.1f}"),
        ]), color=c, outline=True), width=2))

    return fig, cards


if __name__ == "__main__":
    app.run(debug=True, port=8050)

"""
EMA Chart — Exponential Moving Average overlay on candlestick
"""
import os
from datetime import datetime, timedelta
from pathlib import Path

import pandas as pd
import plotly.graph_objects as go
from dotenv import find_dotenv, load_dotenv
from openalgo import api, ta

script_dir = Path(__file__).resolve().parent
load_dotenv(find_dotenv(), override=False)

SYMBOL = "SBIN"
EXCHANGE = "NSE"
INTERVAL = "D"
EMA_FAST = 10
EMA_SLOW = 20
EMA_LONG = 50

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

end_date = datetime.now().date()
start_date = end_date - timedelta(days=365)

df = client.history(
    symbol=SYMBOL, exchange=EXCHANGE, interval=INTERVAL,
    start_date=start_date.strftime("%Y-%m-%d"),
    end_date=end_date.strftime("%Y-%m-%d"),
)
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)
df = df.sort_index()
if df.index.tz is not None:
    df.index = df.index.tz_convert(None)

close = df["close"]

# Compute EMAs
ema_fast = ta.ema(close, EMA_FAST)
ema_slow = ta.ema(close, EMA_SLOW)
ema_long = ta.ema(close, EMA_LONG)

# Crossover signals
buy_signals = ta.crossover(ema_fast, ema_slow)
sell_signals = ta.crossunder(ema_fast, ema_slow)

x_labels = df.index.strftime("%Y-%m-%d")

fig = go.Figure()

fig.add_trace(go.Candlestick(
    x=x_labels, open=df["open"], high=df["high"], low=df["low"], close=close,
    name="Price",
))

fig.add_trace(go.Scatter(
    x=x_labels, y=ema_fast, mode="lines",
    name=f"EMA({EMA_FAST})", line=dict(color="cyan", width=1.5),
))
fig.add_trace(go.Scatter(
    x=x_labels, y=ema_slow, mode="lines",
    name=f"EMA({EMA_SLOW})", line=dict(color="orange", width=1.5),
))
fig.add_trace(go.Scatter(
    x=x_labels, y=ema_long, mode="lines",
    name=f"EMA({EMA_LONG})", line=dict(color="magenta", width=1, dash="dash"),
))

# Buy signals
buy_idx = [x_labels[i] for i in range(len(buy_signals)) if buy_signals[i]]
buy_prices = [close.iloc[i] for i in range(len(buy_signals)) if buy_signals[i]]
fig.add_trace(go.Scatter(
    x=buy_idx, y=buy_prices, mode="markers", name="Buy",
    marker=dict(symbol="triangle-up", size=12, color="lime"),
))

# Sell signals
sell_idx = [x_labels[i] for i in range(len(sell_signals)) if sell_signals[i]]
sell_prices = [close.iloc[i] for i in range(len(sell_signals)) if sell_signals[i]]
fig.add_trace(go.Scatter(
    x=sell_idx, y=sell_prices, mode="markers", name="Sell",
    marker=dict(symbol="triangle-down", size=12, color="red"),
))

fig.update_layout(
    template="plotly_dark",
    title=f"{SYMBOL} — EMA({EMA_FAST}/{EMA_SLOW}/{EMA_LONG})",
    xaxis_rangeslider_visible=False,
    xaxis_type="category",
    height=600,
)
fig.update_yaxes(side="right")

fig.write_html(script_dir / f"{SYMBOL}_ema_chart.html")
fig.show()

# Explanation
current_fast = ema_fast.iloc[-1]
current_slow = ema_slow.iloc[-1]
current_price = close.iloc[-1]
trend = "bullish" if current_fast > current_slow else "bearish"
above_long = "above" if current_price > ema_long.iloc[-1] else "below"

print(f"\n{SYMBOL} — EMA Analysis")
print(f"Price: {current_price:.2f}")
print(f"EMA({EMA_FAST}): {current_fast:.2f}")
print(f"EMA({EMA_SLOW}): {current_slow:.2f}")
print(f"EMA({EMA_LONG}): {ema_long.iloc[-1]:.2f}")
print(f"Short-term trend: {trend} (EMA {EMA_FAST} {'>' if trend == 'bullish' else '<'} EMA {EMA_SLOW})")
print(f"Long-term position: Price {above_long} EMA({EMA_LONG})")

"""
Real-Time Indicator Feed — WebSocket streaming with live indicator computation
"""
import os
import time
import numpy as np
from datetime import datetime, timedelta
from dotenv import find_dotenv, load_dotenv
from openalgo import api, ta

load_dotenv(find_dotenv(), override=False)

SYMBOL = "SBIN"
EXCHANGE = "NSE"
EMA_PERIOD = 20
RSI_PERIOD = 14
BUFFER_SIZE = 200

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

# Pre-fetch historical data for buffer initialization
print(f"Fetching historical data for {SYMBOL} buffer...")
try:
    df = client.history(
        symbol=SYMBOL, exchange=EXCHANGE, interval="1m",
        start_date=(datetime.now() - timedelta(days=2)).strftime("%Y-%m-%d"),
        end_date=datetime.now().strftime("%Y-%m-%d"),
    )
    close_buffer = list(df["close"].values[-BUFFER_SIZE:])
    print(f"Buffer initialized with {len(close_buffer)} historical bars")
except Exception as e:
    print(f"Could not fetch history: {e}")
    close_buffer = []

instruments = [{"exchange": EXCHANGE, "symbol": SYMBOL}]
tick_count = 0
start_time = time.time()


def on_data(data):
    global tick_count
    ltp = data["data"].get("ltp")
    if ltp is None:
        return

    tick_count += 1
    close_buffer.append(float(ltp))

    # Keep buffer size capped
    if len(close_buffer) > BUFFER_SIZE:
        close_buffer.pop(0)

    if len(close_buffer) >= max(EMA_PERIOD, RSI_PERIOD + 1):
        arr = np.array(close_buffer, dtype=np.float64)
        ema_val = ta.ema(arr, EMA_PERIOD)[-1]
        rsi_val = ta.rsi(arr, RSI_PERIOD)[-1]

        # Determine bias
        if rsi_val > 70:
            bias = "OVERBOUGHT"
        elif rsi_val < 30:
            bias = "OVERSOLD"
        elif ltp > ema_val:
            bias = "BULLISH"
        else:
            bias = "BEARISH"

        timestamp = datetime.now().strftime("%H:%M:%S")
        print(f"[{timestamp}] {SYMBOL:>10} "
              f"LTP:{ltp:>10.2f} | "
              f"EMA({EMA_PERIOD}):{ema_val:>10.2f} | "
              f"RSI({RSI_PERIOD}):{rsi_val:>6.2f} | "
              f"{bias}")


# Connect and subscribe
print(f"\nConnecting to WebSocket...")
client.connect()
client.subscribe_ltp(instruments, on_data_received=on_data)

print(f"Streaming {SYMBOL} on {EXCHANGE}")
print(f"Computing: EMA({EMA_PERIOD}), RSI({RSI_PERIOD})")
print(f"Press Ctrl+C to stop\n")
print(f"{'Time':<12} {'Symbol':>10} {'LTP':>12} {'EMA':>12} {'RSI':>8} {'Bias'}")
print("-" * 70)

try:
    while True:
        time.sleep(1)
except KeyboardInterrupt:
    elapsed = time.time() - start_time
    print(f"\n{'='*50}")
    print(f"Session Summary")
    print(f"Duration: {elapsed:.0f} seconds")
    print(f"Ticks received: {tick_count}")
    print(f"Ticks/sec: {tick_count / max(elapsed, 1):.1f}")
    print(f"Buffer size: {len(close_buffer)} bars")

# Cleanup
client.unsubscribe_ltp(instruments)
client.disconnect()
print("Disconnected.")

"""
MACD Chart — Moving Average Convergence Divergence with histogram
"""
import os
from datetime import datetime, timedelta
from pathlib import Path

import pandas as pd
import plotly.graph_objects as go
from plotly.subplots import make_subplots
from dotenv import find_dotenv, load_dotenv
from openalgo import api, ta

script_dir = Path(__file__).resolve().parent
load_dotenv(find_dotenv(), override=False)

SYMBOL = "SBIN"
EXCHANGE = "NSE"
INTERVAL = "D"
FAST = 12
SLOW = 26
SIGNAL = 9

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

end_date = datetime.now().date()
start_date = end_date - timedelta(days=365)

df = client.history(
    symbol=SYMBOL, exchange=EXCHANGE, interval=INTERVAL,
    start_date=start_date.strftime("%Y-%m-%d"),
    end_date=end_date.strftime("%Y-%m-%d"),
)
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)
df = df.sort_index()
if df.index.tz is not None:
    df.index = df.index.tz_convert(None)

close = df["close"]
macd_line, signal_line, histogram = ta.macd(close, FAST, SLOW, SIGNAL)

x_labels = df.index.strftime("%Y-%m-%d")

fig = make_subplots(
    rows=2, cols=1, shared_xaxes=True,
    row_heights=[0.6, 0.4], vertical_spacing=0.03,
    subplot_titles=[f"{SYMBOL} Price", f"MACD({FAST},{SLOW},{SIGNAL})"],
)

# Price
fig.add_trace(go.Candlestick(
    x=x_labels, open=df["open"], high=df["high"], low=df["low"], close=close,
    name="Price", showlegend=False,
), row=1, col=1)

# MACD line
fig.add_trace(go.Scatter(
    x=x_labels, y=macd_line, mode="lines",
    name="MACD", line=dict(color="cyan", width=1.5),
), row=2, col=1)

# Signal line
fig.add_trace(go.Scatter(
    x=x_labels, y=signal_line, mode="lines",
    name="Signal", line=dict(color="orange", width=1.5),
), row=2, col=1)

# Histogram
colors = ["rgba(0,200,0,0.6)" if v >= 0 else "rgba(200,0,0,0.6)" for v in histogram]
fig.add_trace(go.Bar(
    x=x_labels, y=histogram, name="Histogram",
    marker_color=colors,
), row=2, col=1)

# Zero line
fig.add_hline(y=0, line_dash="solid", line_color="gray", opacity=0.3, row=2, col=1)

fig.update_layout(
    template="plotly_dark",
    title=f"{SYMBOL} — MACD({FAST},{SLOW},{SIGNAL})",
    xaxis_rangeslider_visible=False,
    height=700,
)
fig.update_xaxes(type="category", row=1, col=1)
fig.update_xaxes(type="category", row=2, col=1)
fig.update_yaxes(side="right")

fig.write_html(script_dir / f"{SYMBOL}_macd_chart.html")
fig.show()

# Explanation
current_macd = macd_line.iloc[-1]
current_signal = signal_line.iloc[-1]
current_hist = histogram.iloc[-1]
crossover = "bullish" if current_macd > current_signal else "bearish"
momentum = "increasing" if current_hist > histogram.iloc[-2] else "decreasing"

print(f"\n{SYMBOL} — MACD Analysis")
print(f"MACD Line: {current_macd:.4f}")
print(f"Signal Line: {current_signal:.4f}")
print(f"Histogram: {current_hist:.4f}")
print(f"Crossover: {crossover} (MACD {'>' if crossover == 'bullish' else '<'} Signal)")
print(f"Momentum: {momentum}")

"""
Multi-Indicator Chart — Candlestick + EMA + RSI + MACD + Volume
Complete technical analysis in one view
"""
import os
from datetime import datetime, timedelta
from pathlib import Path

import numpy as np
import pandas as pd
import plotly.graph_objects as go
from plotly.subplots import make_subplots
from dotenv import find_dotenv, load_dotenv
from openalgo import api, ta

script_dir = Path(__file__).resolve().parent
load_dotenv(find_dotenv(), override=False)

SYMBOL = "SBIN"
EXCHANGE = "NSE"
INTERVAL = "D"

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

end_date = datetime.now().date()
start_date = end_date - timedelta(days=365)

df = client.history(
    symbol=SYMBOL, exchange=EXCHANGE, interval=INTERVAL,
    start_date=start_date.strftime("%Y-%m-%d"),
    end_date=end_date.strftime("%Y-%m-%d"),
)
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)
df = df.sort_index()
if df.index.tz is not None:
    df.index = df.index.tz_convert(None)

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

# Compute all indicators
ema_20 = ta.ema(close, 20)
ema_50 = ta.ema(close, 50)
rsi = ta.rsi(close, 14)
macd_line, signal_line, histogram = ta.macd(close, 12, 26, 9)

x_labels = df.index.strftime("%Y-%m-%d")

fig = make_subplots(
    rows=4, cols=1, shared_xaxes=True,
    row_heights=[0.4, 0.2, 0.2, 0.2],
    vertical_spacing=0.025,
    subplot_titles=[
        f"{SYMBOL} Price + EMA(20/50)",
        "RSI(14)",
        "MACD(12,26,9)",
        "Volume",
    ],
)

# Row 1: Candlestick + EMA
fig.add_trace(go.Candlestick(
    x=x_labels, open=df["open"], high=high, low=low, close=close,
    name="Price", showlegend=False,
), row=1, col=1)
fig.add_trace(go.Scatter(
    x=x_labels, y=ema_20, mode="lines",
    name="EMA(20)", line=dict(color="cyan", width=1.5),
), row=1, col=1)
fig.add_trace(go.Scatter(
    x=x_labels, y=ema_50, mode="lines",
    name="EMA(50)", line=dict(color="orange", width=1.5),
), row=1, col=1)

# Row 2: RSI
fig.add_trace(go.Scatter(
    x=x_labels, y=rsi, mode="lines",
    name="RSI(14)", line=dict(color="yellow", width=1.5),
), row=2, col=1)
fig.add_hline(y=70, line_dash="dash", line_color="red", opacity=0.5, row=2, col=1)
fig.add_hline(y=30, line_dash="dash", line_color="green", opacity=0.5, row=2, col=1)
fig.update_yaxes(range=[0, 100], row=2, col=1)

# Row 3: MACD
fig.add_trace(go.Scatter(
    x=x_labels, y=macd_line, mode="lines",
    name="MACD", line=dict(color="cyan", width=1),
), row=3, col=1)
fig.add_trace(go.Scatter(
    x=x_labels, y=signal_line, mode="lines",
    name="Signal", line=dict(color="orange", width=1),
), row=3, col=1)
hist_colors = ["rgba(0,200,0,0.6)" if v >= 0 else "rgba(200,0,0,0.6)" for v in histogram]
fig.add_trace(go.Bar(
    x=x_labels, y=histogram, name="Histogram",
    marker_color=hist_colors,
), row=3, col=1)
fig.add_hline(y=0, line_color="gray", opacity=0.3, row=3, col=1)

# Row 4: Volume
vol_colors = ["green" if c >= o else "red" for c, o in zip(close, df["open"])]
fig.add_trace(go.Bar(
    x=x_labels, y=volume, name="Volume",
    marker_color=vol_colors, opacity=0.5,
), row=4, col=1)

fig.update_layout(
    template="plotly_dark",
    title=f"{SYMBOL} — Complete Technical Analysis",
    xaxis_rangeslider_visible=False,
    height=1000,
    showlegend=True,
    legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1),
)
for r in range(1, 5):
    fig.update_xaxes(type="category", row=r, col=1)
    fig.update_yaxes(side="right", row=r, col=1)

fig.write_html(script_dir / f"{SYMBOL}_multi_indicator_chart.html")
fig.show()

# Summary
print(f"\n{SYMBOL} — Technical Analysis Summary")
print(f"{'='*50}")
print(f"Price: {close.iloc[-1]:.2f}")
print(f"EMA(20): {ema_20.iloc[-1]:.2f} {'(above)' if close.iloc[-1] > ema_20.iloc[-1] else '(below)'}")
print(f"EMA(50): {ema_50.iloc[-1]:.2f} {'(above)' if close.iloc[-1] > ema_50.iloc[-1] else '(below)'}")
print(f"RSI(14): {rsi.iloc[-1]:.2f}")
print(f"MACD: {macd_line.iloc[-1]:.4f} | Signal: {signal_line.iloc[-1]:.4f}")
print(f"Volume: {volume.iloc[-1]:,.0f}")

# Overall bias
bullish_count = 0
if close.iloc[-1] > ema_20.iloc[-1]: bullish_count += 1
if close.iloc[-1] > ema_50.iloc[-1]: bullish_count += 1
if ema_20.iloc[-1] > ema_50.iloc[-1]: bullish_count += 1
if rsi.iloc[-1] > 50: bullish_count += 1
if macd_line.iloc[-1] > signal_line.iloc[-1]: bullish_count += 1

print(f"\nOverall Bias: {bullish_count}/5 bullish conditions met")
if bullish_count >= 4:
    print("Assessment: STRONGLY BULLISH")
elif bullish_count >= 3:
    print("Assessment: MODERATELY BULLISH")
elif bullish_count == 2:
    print("Assessment: NEUTRAL / MIXED")
elif bullish_count == 1:
    print("Assessment: MODERATELY BEARISH")
else:
    print("Assessment: STRONGLY BEARISH")