!pip install pandas numpy plotly

import warnings
warnings.filterwarnings("ignore")

import pandas as pd
import numpy as np
import plotly.graph_objects as go

def generate_data(periods: int) -> pd.DataFrame:
    start_date     = pd.to_datetime("2024-01-01 00:00:00+00:00")
    datetime_index = pd.date_range(start_date, periods=periods, freq="1min", tz="UTC")
    price_data = []; last_close = 42000
    volatility_scale = 0.005; wick_deviation_scale = 0.002
    for i in range(periods):
        open_price   = last_close + np.random.normal(0, last_close * volatility_scale * 0.1)
        close_price  = open_price + np.random.normal(0, last_close * volatility_scale)
        body_high    = max(open_price, close_price)
        body_low     = min(open_price, close_price)
        high_price   = max(body_high + abs(np.random.normal(0, last_close * wick_deviation_scale)), open_price, close_price)
        low_price    = min(body_low  - abs(np.random.normal(0, last_close * wick_deviation_scale)), open_price, close_price)
        if high_price < low_price: high_price, low_price = low_price, high_price
        price_data.append({"open": max(1,int(open_price)), "high": max(1,int(high_price)),
                            "low": max(1,int(low_price)),  "close": max(1,int(close_price))})
        last_close = close_price
    df = pd.DataFrame(price_data, index=datetime_index)
    df.index.name = "datetime"
    df["volume"] = np.random.uniform(100.0, 500.0, periods)
    df["datetime"] = df.index.to_series()
    return df.reset_index(drop=True)

df = generate_data(500)
display(df.head())

def donchian_breakout_strategy(
    df:     pd.DataFrame,
    window: int = 20,
) -> pd.DataFrame:
    df = df.copy().sort_values("datetime", ignore_index=True)

    # Channel boundaries from the previous candle's rolling window
    # (shift(1) prevents lookahead — the current candle cannot see its own high/low
    #  as part of the channel that triggered its own breakout signal)
    df["dc_upper"]  = df["high"].shift(1).rolling(window).max()
    df["dc_lower"]  = df["low"].shift(1).rolling(window).min()
    df["dc_middle"] = (df["dc_upper"] + df["dc_lower"]) / 2

    df["signal"] = np.where(df["close"] >= df["dc_upper"],  1,
                   np.where(df["close"] <= df["dc_lower"], -1, 0))

    return df

df_signals = donchian_breakout_strategy(df, window=20)

print("--- Signal Distribution ---")
print(df_signals["signal"].value_counts())
display(df_signals[["datetime","close","dc_upper","dc_lower","dc_middle","signal"]].dropna().head(20))

buy_signals  = df_signals[df_signals["signal"] ==  1]
sell_signals = df_signals[df_signals["signal"] == -1]

fig = go.FigureWidget(data=[go.Candlestick(
    x=df_signals["datetime"],
    open=df_signals["open"], high=df_signals["high"],
    low=df_signals["low"],   close=df_signals["close"],
    name="Price"
)])

fig.add_trace(go.Scatter(x=df_signals["datetime"], y=df_signals["dc_upper"],
    mode="lines", name="DC Upper", line=dict(color="blue",  width=1, dash="dash")))
fig.add_trace(go.Scatter(x=df_signals["datetime"], y=df_signals["dc_lower"],
    mode="lines", name="DC Lower", line=dict(color="blue",  width=1, dash="dash")))
fig.add_trace(go.Scatter(x=df_signals["datetime"], y=df_signals["dc_middle"],
    mode="lines", name="DC Middle",line=dict(color="gray",  width=1, dash="dot")))

fig.add_trace(go.Scatter(
    x=buy_signals["datetime"],  y=buy_signals["low"]  * 0.999,
    mode="markers", marker=dict(symbol="triangle-up",   size=10, color="green"), name="Buy (+1)"))
fig.add_trace(go.Scatter(
    x=sell_signals["datetime"], y=sell_signals["high"] * 1.001,
    mode="markers", marker=dict(symbol="triangle-down", size=10, color="red"),   name="Sell (−1)"))

fig.update_layout(
    title_text="Donchian Channel Breakout Strategy",
    xaxis_rangeslider_visible=False,
    xaxis_title="Datetime", yaxis_title="Price",
    height=600, yaxis=dict(autorange=True),
)
fig.show()