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):
    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
    for i in range(periods):
        open_price  = last_close + np.random.normal(0, last_close * 0.0005)
        close_price = open_price + np.random.normal(0, last_close * 0.005)
        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 * 0.002)), open_price, close_price)
        low_price   = min(body_low  - abs(np.random.normal(0, last_close * 0.002)), 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)

def dynamic_stop_volatility_strategy(
    df: pd.DataFrame,
    atr_window: int = 14,
    stop_mult: float = 2.0,
    target_mult: float = 3.0,
) -> pd.DataFrame:
    """
    Computes dynamic stop-loss and profit-target levels based on the Average True Range (ATR).

    Parameters:
    - df (pd.DataFrame): DataFrame containing OHLCV data with 'high', 'low', and 'close' columns.
    - atr_window (int): The lookback period for calculating the ATR. Default is 14.
    - stop_mult (float): Multiplier for ATR to determine the stop-loss distance. Default is 2.0.
    - target_mult (float): Multiplier for ATR to determine the profit-target distance. Default is 3.0.

    Returns:
    - pd.DataFrame: The input DataFrame with added columns for 'atr', 'stop_long', 'target_long',
      'stop_short', 'target_short', and 'rr_ratio'.
    """
    df = df.copy().sort_values("datetime", ignore_index=True)

    # Calculate True Range (TR) as the greatest of the following:
    # 1. Current High minus Current Low
    # 2. Absolute value of Current High minus Previous Close
    # 3. Absolute value of Current Low minus Previous Close
    tr = pd.concat([
        df["high"] - df["low"],
        (df["high"] - df["close"].shift(1)).abs(),
        (df["low"]  - df["close"].shift(1)).abs(),
    ], axis=1).max(axis=1)

    # Calculate Average True Range (ATR) by taking a rolling mean of TR
    df["atr"] = tr.rolling(atr_window).mean()

    # Calculate dynamic stop-loss and profit-target levels for long positions
    df["stop_long"] = df["close"] - stop_mult * df["atr"]
    df["target_long"] = df["close"] + target_mult * df["atr"]

    # Calculate dynamic stop-loss and profit-target levels for short positions
    df["stop_short"] = df["close"] + stop_mult * df["atr"]
    df["target_short"] = df["close"] - target_mult * df["atr"]

    # Calculate the reward-to-risk ratio
    df["rr_ratio"] = target_mult / stop_mult

    return df

df_levels = dynamic_stop_volatility_strategy(df, atr_window=14, stop_mult=2.0, target_mult=3.0)

print("--- Dynamic Stop/Target Levels (last 10 candles) ---")
display(df_levels[["datetime","close","atr","stop_long","target_long","rr_ratio"]].tail(10).round(2))

fig = go.FigureWidget(data=[go.Candlestick(
    x=df_levels["datetime"], open=df_levels["open"], high=df_levels["high"],
    low=df_levels["low"],    close=df_levels["close"], name="Price")])
fig.add_trace(go.Scatter(x=df_levels["datetime"], y=df_levels["stop_long"],
    mode="lines", name="Stop (Long)",   line=dict(color="red",   width=1, dash="dash")))
fig.add_trace(go.Scatter(x=df_levels["datetime"], y=df_levels["target_long"],
    mode="lines", name="Target (Long)", line=dict(color="green", width=1, dash="dash")))
fig.add_trace(go.Scatter(x=df_levels["datetime"], y=df_levels["atr"],
    mode="lines", name="ATR", line=dict(color="purple", width=1), yaxis="y2"))
fig.update_layout(title_text="Dynamic ATR-Based Stop and Target Levels",
    xaxis_rangeslider_visible=False, height=600, yaxis=dict(autorange=True),
    yaxis2=dict(title="ATR", overlaying="y", side="right"))
fig.show()