!pip install pandas numpy

import warnings
warnings.filterwarnings("ignore")

import pandas as pd
import numpy as np

raw_data = {
    "datetime": [
        "2024-01-01 00:00:00+00:00",
        "2024-01-01 00:01:00+00:00",
        "2024-01-01 00:02:00+00:00",
        "2024-01-01 00:03:00+00:00",
        "2024-01-01 00:04:00+00:00",
        "2024-01-01 00:05:00+00:00",
        "2024-01-01 00:06:00+00:00",
        "2024-01-01 00:07:00+00:00",
        "2024-01-01 00:08:00+00:00",
        "2024-01-01 00:09:00+00:00",
    ],
    "open":   [42100, 42200, 42150, 42300, 42250,
               42400, 42350, 42500, 42450, 42600],
    "high":   [42300, 42400, 42350, 42500, 42450,
               42600, 42550, 42700, 42650, 42800],
    "low":    [41900, 42000, 41950, 42100, 42050,
               42200, 42150, 42300, 42250, 42400],
    "close":  [42200, 42150, 42300, 42250, 42400,
               42350, 42500, 42450, 42600, 42550],
    "volume": [10.5, 8.2, 9.1, 11.3, 7.6,
               12.4, 6.8, 13.1, 9.9, 10.2],
}

df = pd.DataFrame(raw_data)
df["datetime"] = pd.to_datetime(df["datetime"], utc=True)

print("--- Raw OHLCV Data ---")
display(df)

def analyze_price(df: pd.DataFrame, rolling_window: int = 5) -> pd.DataFrame:
    """
    Compute price movement indicators from OHLCV data.

    Args:
        df             (pd.DataFrame): Cleaned OHLCV DataFrame with UTC datetime column.
        rolling_window (int):          Number of candles for rolling mean calculation.

    Returns:
        pd.DataFrame: Input DataFrame extended with computed price metrics.
    """
    df = df.copy().sort_values("datetime", ignore_index=True)

    # Simple return: percentage change from previous close to current close
    df["simple_return"]     = df["close"].pct_change()

    # Log return: natural log of the price ratio between consecutive closes
    df["log_return"]        = np.log(df["close"] / df["close"].shift(1))

    # Cumulative return: total percentage change from the first close price
    df["cumulative_return"] = (df["close"] / df["close"].iloc[0]) - 1

    # Rolling mean: average close price over the last N candles
    df["rolling_mean"]      = df["close"].rolling(window=rolling_window).mean()

    # Price range: distance between high and low within each candle
    df["price_range"]       = df["high"] - df["low"]

    # Price direction: +1 if close is higher than open (up candle),
    #                 -1 if close is lower than open (down candle),
    #                  0 if unchanged
    df["direction"]         = np.sign(df["close"] - df["open"]).astype(int)

    return df[[
        "datetime", "open", "high", "low", "close", "volume",
        "simple_return", "log_return", "cumulative_return",
        "rolling_mean", "price_range", "direction",
    ]]

ROLLING_WINDOW = 5

df_analysis = analyze_price(df, rolling_window=ROLLING_WINDOW)

print("--- Price Analysis Output ---")
display(df_analysis)

print("--- Return Summary ---")
display(df_analysis[["simple_return", "log_return", "cumulative_return"]].describe().round(6))

print("\n--- Price Range Summary ---")
display(df_analysis[["price_range"]].describe().round(2))

print("\n--- Direction Distribution ---")
direction_map = {1: "Up", -1: "Down", 0: "Flat"}
print(df_analysis["direction"].map(direction_map).value_counts())

print("\n--- Schema Summary ---")
df_analysis.info()

import matplotlib.pyplot as plt
import seaborn as sns

plt.figure(figsize=(12, 6))
sns.lineplot(x='datetime', y='close', data=df_analysis, label='Close Price')
sns.lineplot(x='datetime', y='rolling_mean', data=df_analysis, label='Rolling Mean')
plt.title('Close Price and Rolling Mean Over Time')
plt.xlabel('Datetime')
plt.ylabel('Price')
plt.legend()
plt.grid(True)
plt.show()

plt.figure(figsize=(12, 6))
sns.lineplot(x='datetime', y='simple_return', data=df_analysis, label='Simple Return')
sns.lineplot(x='datetime', y='log_return', data=df_analysis, label='Log Return')
plt.title('Simple and Log Returns Over Time')
plt.xlabel('Datetime')
plt.ylabel('Return')
plt.legend()
plt.grid(True)
plt.show()

plt.figure(figsize=(12, 6))
sns.lineplot(x='datetime', y='cumulative_return', data=df_analysis, label='Cumulative Return', color='green')
plt.title('Cumulative Return Over Time')
plt.xlabel('Datetime')
plt.ylabel('Cumulative Return')
plt.legend()
plt.grid(True)
plt.show()

plt.figure(figsize=(10, 5))
sns.barplot(x='datetime', y='price_range', data=df_analysis, color='purple')
plt.title('Price Range per Candle')
plt.xlabel('Datetime')
plt.ylabel('Price Range (High - Low)')
plt.xticks(rotation=45)
plt.grid(axis='y')
plt.tight_layout()
plt.show()

plt.figure(figsize=(8, 5))
direction_counts = df_analysis['direction'].map({1: 'Up', -1: 'Down', 0: 'Flat'}).value_counts()
sns.barplot(x=direction_counts.index, y=direction_counts.values, palette='viridis')
plt.title('Distribution of Price Direction (Up/Down Candles)')
plt.xlabel('Direction')
plt.ylabel('Count')
plt.show()