new purpose
This commit is contained in:
Oleg Sheynin
@@ -0,0 +1,17 @@
|
||||
import hjson
|
||||
from typing import Dict
|
||||
from datetime import datetime
|
||||
# ---
|
||||
from cvttpy_tools.base.config import Config
|
||||
|
||||
|
||||
def load_config(config_path: str) -> Config:
|
||||
return Config(json_src=f"file://{config_path}")
|
||||
|
||||
|
||||
def expand_filename(filename: str) -> str:
|
||||
# expand %T
|
||||
res = filename.replace("%T", datetime.now().strftime("%Y%m%d_%H%M%S"))
|
||||
# expand %D
|
||||
return res.replace("%D", datetime.now().strftime("%Y%m%d"))
|
||||
|
||||
@@ -0,0 +1,150 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import sqlite3
|
||||
from typing import Any, Dict, List, Tuple, cast
|
||||
import pandas as pd
|
||||
|
||||
from cvttpy_trading.trading.instrument import ExchangeInstrument
|
||||
|
||||
def load_sqlite_to_dataframe(db_path:str, query:str) -> pd.DataFrame:
|
||||
df: pd.DataFrame = pd.DataFrame()
|
||||
import os
|
||||
if not os.path.exists(db_path):
|
||||
print(f"WARNING: database file {db_path} does not exist")
|
||||
return df
|
||||
|
||||
try:
|
||||
conn = sqlite3.connect(db_path)
|
||||
|
||||
df = pd.read_sql_query(query, conn)
|
||||
return df
|
||||
except sqlite3.Error as excpt:
|
||||
print(f"SQLite error: {excpt}")
|
||||
raise
|
||||
except Exception as excpt:
|
||||
print(f"Error: {excpt}")
|
||||
raise Exception() from excpt
|
||||
finally:
|
||||
if "conn" in locals():
|
||||
conn.close()
|
||||
|
||||
|
||||
def convert_time_to_UTC(value: str, timezone: str, extra_minutes: int = 0) -> str:
|
||||
|
||||
from zoneinfo import ZoneInfo
|
||||
from datetime import datetime, timedelta
|
||||
|
||||
# Parse it to naive datetime object
|
||||
local_dt = datetime.strptime(value, "%Y-%m-%d %H:%M:%S")
|
||||
local_dt = local_dt + timedelta(minutes=extra_minutes)
|
||||
|
||||
zinfo = ZoneInfo(timezone)
|
||||
result: datetime = local_dt.replace(tzinfo=zinfo).astimezone(ZoneInfo("UTC"))
|
||||
|
||||
return result.strftime("%Y-%m-%d %H:%M:%S")
|
||||
|
||||
|
||||
def load_market_data(
|
||||
datafile: str,
|
||||
instruments: List[ExchangeInstrument],
|
||||
db_table_name: str,
|
||||
trading_hours: Dict = {},
|
||||
extra_minutes: int = 0,
|
||||
) -> pd.DataFrame:
|
||||
|
||||
|
||||
inst_ids = ['"' + exch_inst.instrument_id() + '"' for exch_inst in instruments]
|
||||
instrument_ids = list(set(inst_ids))
|
||||
exchange_ids = list(
|
||||
set(['"' + instrument.exchange_id() + '"' for instrument in instruments])
|
||||
)
|
||||
|
||||
query = "select"
|
||||
query += " tstamp"
|
||||
query += ", tstamp_ns as time_ns"
|
||||
|
||||
query += f", substr(instrument_id, instr(instrument_id, '-') + 1) as symbol"
|
||||
query += ", open"
|
||||
query += ", high"
|
||||
query += ", low"
|
||||
query += ", close"
|
||||
query += ", volume"
|
||||
query += ", num_trades"
|
||||
query += ", vwap"
|
||||
|
||||
query += f" from {db_table_name}"
|
||||
query += f" where exchange_id in ({','.join(exchange_ids)})"
|
||||
query += f" and instrument_id in ({','.join(instrument_ids)})"
|
||||
|
||||
df = load_sqlite_to_dataframe(db_path=datafile, query=query)
|
||||
|
||||
# Trading Hours
|
||||
if len(df) > 0 and len(trading_hours) > 0:
|
||||
date_str = df["tstamp"][0][0:10]
|
||||
|
||||
start_time = convert_time_to_UTC(
|
||||
f"{date_str} {trading_hours['begin_session']}", trading_hours["timezone"]
|
||||
)
|
||||
end_time = convert_time_to_UTC(
|
||||
f"{date_str} {trading_hours['end_session']}", trading_hours["timezone"], extra_minutes=extra_minutes # to get execution price
|
||||
)
|
||||
|
||||
# Perform boolean selection
|
||||
df = df[(df["tstamp"] >= start_time) & (df["tstamp"] <= end_time)]
|
||||
df["tstamp"] = pd.to_datetime(df["tstamp"])
|
||||
|
||||
return cast(pd.DataFrame, df)
|
||||
|
||||
|
||||
# def get_available_instruments_from_db(datafile: str, config: Dict) -> List[str]:
|
||||
# """
|
||||
# Auto-detect available instruments from the database by querying distinct instrument_id values.
|
||||
# Returns instruments without the configured prefix.
|
||||
# """
|
||||
# try:
|
||||
# conn = sqlite3.connect(datafile)
|
||||
|
||||
# # Build exclusion list with full instrument_ids
|
||||
# exclude_instruments = config.get("exclude_instruments", [])
|
||||
# prefix = config.get("instrument_id_pfx", "")
|
||||
# exclude_instrument_ids = [f"{prefix}{inst}" for inst in exclude_instruments]
|
||||
|
||||
# # Query to get distinct instrument_ids
|
||||
# query = f"""
|
||||
# SELECT DISTINCT instrument_id
|
||||
# FROM {config['db_table_name']}
|
||||
# WHERE exchange_id = ?
|
||||
# """
|
||||
|
||||
# # Add exclusion clause if there are instruments to exclude
|
||||
# if exclude_instrument_ids:
|
||||
# placeholders = ",".join(["?" for _ in exclude_instrument_ids])
|
||||
# query += f" AND instrument_id NOT IN ({placeholders})"
|
||||
# cursor = conn.execute(
|
||||
# query, (config["exchange_id"],) + tuple(exclude_instrument_ids)
|
||||
# )
|
||||
# else:
|
||||
# cursor = conn.execute(query, (config["exchange_id"],))
|
||||
# instrument_ids = [row[0] for row in cursor.fetchall()]
|
||||
# conn.close()
|
||||
|
||||
# # Remove the configured prefix to get instrument symbols
|
||||
# instruments = []
|
||||
# for instrument_id in instrument_ids:
|
||||
# if instrument_id.startswith(prefix):
|
||||
# symbol = instrument_id[len(prefix) :]
|
||||
# instruments.append(symbol)
|
||||
# else:
|
||||
# instruments.append(instrument_id)
|
||||
|
||||
# return sorted(instruments)
|
||||
|
||||
# except Exception as e:
|
||||
# print(f"Error auto-detecting instruments from {datafile}: {str(e)}")
|
||||
# return []
|
||||
|
||||
|
||||
# if __name__ == "__main__":
|
||||
# df1 = load_sqlite_to_dataframe(sys.argv[1], table_name="md_1min_bars")
|
||||
|
||||
# print(df1)
|
||||
@@ -0,0 +1,37 @@
|
||||
import os
|
||||
import glob
|
||||
from typing import Dict, List, Tuple
|
||||
# ---
|
||||
from cvttpy_tools.base.config import Config
|
||||
# ---
|
||||
from cvttpy_trading.trading.instrument import ExchangeInstrument
|
||||
|
||||
DayT = str
|
||||
DataFileNameT = str
|
||||
|
||||
def resolve_datafiles(
|
||||
config: Config, date_pattern: str, instruments: List[ExchangeInstrument]
|
||||
) -> List[Tuple[DayT, DataFileNameT]]:
|
||||
resolved_files: List[Tuple[DayT, DataFileNameT]] = []
|
||||
for exch_inst in instruments:
|
||||
pattern = date_pattern
|
||||
inst_type = exch_inst.user_data_.get("instrument_type", "?instrument_type?")
|
||||
data_dir = config.get_value(f"market_data_loading/{inst_type}/data_directory")
|
||||
if "*" in pattern or "?" in pattern:
|
||||
# Handle wildcards
|
||||
if not os.path.isabs(pattern):
|
||||
pattern = os.path.join(data_dir, f"{pattern}.mktdata.ohlcv.db")
|
||||
matched_files = glob.glob(pattern)
|
||||
for matched_file in matched_files:
|
||||
import re
|
||||
match = re.search(r"(\d{8})\.mktdata\.ohlcv\.db$", matched_file)
|
||||
assert match is not None
|
||||
day = match.group(1)
|
||||
resolved_files.append((day, matched_file))
|
||||
else:
|
||||
# Handle explicit file path
|
||||
if not os.path.isabs(pattern):
|
||||
pattern = os.path.join(data_dir, f"{pattern}.mktdata.ohlcv.db")
|
||||
resolved_files.append((date_pattern, pattern))
|
||||
return sorted(list(set(resolved_files))) # Remove duplicates and sort
|
||||
|
||||
@@ -0,0 +1,79 @@
|
||||
from pairs_trading.lib.pt_strategy.research_strategy import PtResearchStrategy
|
||||
|
||||
|
||||
def visualize_prices(strategy: PtResearchStrategy, trading_date: str) -> None:
|
||||
# Plot raw price data
|
||||
import matplotlib.pyplot as plt
|
||||
# Set plotting style
|
||||
import seaborn as sns
|
||||
|
||||
pair = strategy.trading_pair_
|
||||
SYMBOL_A = pair.symbol_a()
|
||||
SYMBOL_B = pair.symbol_b()
|
||||
TRD_DATE = f"{trading_date[0:4]}-{trading_date[4:6]}-{trading_date[6:8]}"
|
||||
|
||||
plt.style.use('seaborn-v0_8')
|
||||
sns.set_palette("husl")
|
||||
plt.rcParams['figure.figsize'] = (15, 10)
|
||||
|
||||
# Get column names for the trading pair
|
||||
colname_a, colname_b = pair.colnames()
|
||||
price_data = strategy.pt_mkt_data_.market_data_df_.copy()
|
||||
|
||||
# Create separate subplots for better visibility
|
||||
fig_price, price_axes = plt.subplots(2, 1, figsize=(18, 10))
|
||||
|
||||
# Plot SYMBOL_A
|
||||
price_axes[0].plot(price_data['tstamp'], price_data[colname_a], alpha=0.7,
|
||||
label=f'{SYMBOL_A}', linewidth=1, color='blue')
|
||||
price_axes[0].set_title(f'{SYMBOL_A} Price Data ({TRD_DATE})')
|
||||
price_axes[0].set_ylabel(f'{SYMBOL_A} Price')
|
||||
price_axes[0].legend()
|
||||
price_axes[0].grid(True)
|
||||
|
||||
# Plot SYMBOL_B
|
||||
price_axes[1].plot(price_data['tstamp'], price_data[colname_b], alpha=0.7,
|
||||
label=f'{SYMBOL_B}', linewidth=1, color='red')
|
||||
price_axes[1].set_title(f'{SYMBOL_B} Price Data ({TRD_DATE})')
|
||||
price_axes[1].set_ylabel(f'{SYMBOL_B} Price')
|
||||
price_axes[1].set_xlabel('Time')
|
||||
price_axes[1].legend()
|
||||
price_axes[1].grid(True)
|
||||
|
||||
plt.tight_layout()
|
||||
plt.show()
|
||||
|
||||
|
||||
# Plot individual prices
|
||||
fig, axes = plt.subplots(2, 1, figsize=(18, 12))
|
||||
|
||||
# Normalized prices for comparison
|
||||
norm_a = price_data[colname_a] / price_data[colname_a].iloc[0]
|
||||
norm_b = price_data[colname_b] / price_data[colname_b].iloc[0]
|
||||
|
||||
axes[0].plot(price_data['tstamp'], norm_a, label=f'{SYMBOL_A} (normalized)', alpha=0.8, linewidth=1)
|
||||
axes[0].plot(price_data['tstamp'], norm_b, label=f'{SYMBOL_B} (normalized)', alpha=0.8, linewidth=1)
|
||||
axes[0].set_title(f'Normalized Price Comparison (Base = 1.0) ({TRD_DATE})')
|
||||
axes[0].set_ylabel('Normalized Price')
|
||||
axes[0].legend()
|
||||
axes[0].grid(True)
|
||||
|
||||
# Price ratio
|
||||
price_ratio = price_data[colname_a] / price_data[colname_b]
|
||||
axes[1].plot(price_data['tstamp'], price_ratio, label=f'{SYMBOL_A}/{SYMBOL_B} Ratio', color='green', alpha=0.8, linewidth=1)
|
||||
axes[1].set_title(f'Price Ratio Px({SYMBOL_A})/Px({SYMBOL_B}) ({TRD_DATE})')
|
||||
axes[1].set_ylabel('Ratio')
|
||||
axes[1].set_xlabel('Time')
|
||||
axes[1].legend()
|
||||
axes[1].grid(True)
|
||||
|
||||
plt.tight_layout()
|
||||
plt.show()
|
||||
|
||||
# Print basic statistics
|
||||
print(f"\nPrice Statistics:")
|
||||
print(f" {SYMBOL_A}: Mean=${price_data[colname_a].mean():.2f}, Std=${price_data[colname_a].std():.2f}")
|
||||
print(f" {SYMBOL_B}: Mean=${price_data[colname_b].mean():.2f}, Std=${price_data[colname_b].std():.2f}")
|
||||
print(f" Price Ratio: Mean={price_ratio.mean():.2f}, Std={price_ratio.std():.2f}")
|
||||
print(f" Correlation: {price_data[colname_a].corr(price_data[colname_b]):.4f}")
|
||||
|
||||
@@ -0,0 +1,502 @@
|
||||
from __future__ import annotations
|
||||
|
||||
|
||||
from pairs_trading.lib.pt_strategy.results import (PairResearchResult)
|
||||
from pairs_trading.lib.pt_strategy.research_strategy import PtResearchStrategy
|
||||
|
||||
|
||||
def visualize_trades(strategy: PtResearchStrategy, results: PairResearchResult, trading_date: str) -> None:
|
||||
|
||||
import pandas as pd
|
||||
import plotly.express as px
|
||||
import plotly.graph_objects as go
|
||||
import plotly.offline as pyo
|
||||
from IPython.display import HTML
|
||||
from plotly.subplots import make_subplots
|
||||
|
||||
|
||||
pair = strategy.trading_pair_
|
||||
trades = results.trades_[trading_date].copy()
|
||||
origin_mkt_data_df = strategy.pt_mkt_data_.origin_mkt_data_df_
|
||||
mkt_data_df = strategy.pt_mkt_data_.market_data_df_
|
||||
TRD_DATE = f"{trading_date[0:4]}-{trading_date[4:6]}-{trading_date[6:8]}"
|
||||
SYMBOL_A = pair.symbol_a()
|
||||
SYMBOL_B = pair.symbol_b()
|
||||
|
||||
|
||||
print(f"\nCreated trading pair: {pair}")
|
||||
print(f"Market data shape: {pair.market_data_.shape}")
|
||||
print(f"Column names: {pair.colnames()}")
|
||||
|
||||
# Configure plotly for offline mode
|
||||
pyo.init_notebook_mode(connected=True)
|
||||
|
||||
# Strategy-specific interactive visualization
|
||||
assert strategy.config_ is not None
|
||||
|
||||
print("=== SLIDING FIT INTERACTIVE VISUALIZATION ===")
|
||||
print("Note: Rolling Fit strategy visualization with interactive plotly charts")
|
||||
|
||||
|
||||
# Create consistent timeline - superset of timestamps from both dataframes
|
||||
all_timestamps = sorted(set(mkt_data_df['tstamp']))
|
||||
|
||||
|
||||
# Create a unified timeline dataframe for consistent plotting
|
||||
timeline_df = pd.DataFrame({'tstamp': all_timestamps})
|
||||
|
||||
# Merge with predicted data to get dis-equilibrium values
|
||||
timeline_df = timeline_df.merge(strategy.predictions_df_[['tstamp', 'disequilibrium', 'scaled_disequilibrium', 'signed_scaled_disequilibrium']],
|
||||
on='tstamp', how='left')
|
||||
|
||||
# Get Symbol_A and Symbol_B market data
|
||||
colname_a, colname_b = pair.colnames()
|
||||
symbol_a_data = mkt_data_df[['tstamp', colname_a]].copy()
|
||||
symbol_b_data = mkt_data_df[['tstamp', colname_b]].copy()
|
||||
|
||||
norm_a = symbol_a_data[colname_a] / symbol_a_data[colname_a].iloc[0]
|
||||
norm_b = symbol_b_data[colname_b] / symbol_b_data[colname_b].iloc[0]
|
||||
|
||||
print(f"Using consistent timeline with {len(timeline_df)} timestamps")
|
||||
print(f"Timeline range: {timeline_df['tstamp'].min()} to {timeline_df['tstamp'].max()}")
|
||||
|
||||
# Create subplots with price charts at bottom
|
||||
fig = make_subplots(
|
||||
rows=4, cols=1,
|
||||
row_heights=[0.3, 0.4, 0.15, 0.15],
|
||||
subplot_titles=[
|
||||
f'Dis-equilibrium with Trading Thresholds ({TRD_DATE})',
|
||||
f'Normalized Price Comparison with BUY/SELL Signals - {SYMBOL_A}&{SYMBOL_B} ({TRD_DATE})',
|
||||
f'{SYMBOL_A} Market Data with Trading Signals ({TRD_DATE})',
|
||||
f'{SYMBOL_B} Market Data with Trading Signals ({TRD_DATE})',
|
||||
],
|
||||
vertical_spacing=0.06,
|
||||
specs=[[{"secondary_y": False}],
|
||||
[{"secondary_y": False}],
|
||||
[{"secondary_y": False}],
|
||||
[{"secondary_y": False}]]
|
||||
)
|
||||
|
||||
# 1. Scaled dis-equilibrium with thresholds - using consistent timeline
|
||||
fig.add_trace(
|
||||
go.Scatter(
|
||||
x=timeline_df['tstamp'],
|
||||
y=timeline_df['scaled_disequilibrium'],
|
||||
name='Absolute Scaled Dis-equilibrium',
|
||||
line=dict(color='green', width=2),
|
||||
opacity=0.8
|
||||
),
|
||||
row=1, col=1
|
||||
)
|
||||
|
||||
fig.add_trace(
|
||||
go.Scatter(
|
||||
x=timeline_df['tstamp'],
|
||||
y=timeline_df['signed_scaled_disequilibrium'],
|
||||
name='Scaled Dis-equilibrium',
|
||||
line=dict(color='darkmagenta', width=2),
|
||||
opacity=0.8
|
||||
),
|
||||
row=1, col=1
|
||||
)
|
||||
|
||||
# Add threshold lines to first subplot
|
||||
fig.add_shape(
|
||||
type="line",
|
||||
x0=timeline_df['tstamp'].min(),
|
||||
x1=timeline_df['tstamp'].max(),
|
||||
y0=strategy.config_.get_value('model/disequilibrium/open_trshld'),
|
||||
y1=strategy.config_.get_value('model/disequilibrium/open_trshld'),
|
||||
line=dict(color="purple", width=2, dash="dot"),
|
||||
opacity=0.7,
|
||||
row=1, col=1
|
||||
)
|
||||
|
||||
fig.add_shape(
|
||||
type="line",
|
||||
x0=timeline_df['tstamp'].min(),
|
||||
x1=timeline_df['tstamp'].max(),
|
||||
y0=-strategy.config_.get_value('model/disequilibrium/open_trshld'),
|
||||
y1=-strategy.config_.get_value('model/disequilibrium/open_trshld'),
|
||||
line=dict(color="purple", width=2, dash="dot"),
|
||||
opacity=0.7,
|
||||
row=1, col=1
|
||||
)
|
||||
|
||||
fig.add_shape(
|
||||
type="line",
|
||||
x0=timeline_df['tstamp'].min(),
|
||||
x1=timeline_df['tstamp'].max(),
|
||||
y0=strategy.config_.get_value('model/disequilibrium/close_trshld'),
|
||||
y1=strategy.config_.get_value('model/disequilibrium/close_trshld'),
|
||||
line=dict(color="brown", width=2, dash="dot"),
|
||||
opacity=0.7,
|
||||
row=1, col=1
|
||||
)
|
||||
|
||||
fig.add_shape(
|
||||
type="line",
|
||||
x0=timeline_df['tstamp'].min(),
|
||||
x1=timeline_df['tstamp'].max(),
|
||||
y0=-strategy.config_.get_value('model/disequilibrium/close_trshld'),
|
||||
y1=-strategy.config_.get_value('model/disequilibrium/close_trshld'),
|
||||
line=dict(color="brown", width=2, dash="dot"),
|
||||
opacity=0.7,
|
||||
row=1, col=1
|
||||
)
|
||||
|
||||
fig.add_shape(
|
||||
type="line",
|
||||
x0=timeline_df['tstamp'].min(),
|
||||
x1=timeline_df['tstamp'].max(),
|
||||
y0=0,
|
||||
y1=0,
|
||||
line=dict(color="black", width=1, dash="solid"),
|
||||
opacity=0.5,
|
||||
row=1, col=1
|
||||
)
|
||||
|
||||
# Add normalized price lines
|
||||
fig.add_trace(
|
||||
go.Scatter(
|
||||
x=mkt_data_df['tstamp'],
|
||||
y=norm_a,
|
||||
name=f'{SYMBOL_A} (Normalized)',
|
||||
line=dict(color='blue', width=2),
|
||||
opacity=0.8
|
||||
),
|
||||
row=2, col=1
|
||||
)
|
||||
|
||||
fig.add_trace(
|
||||
go.Scatter(
|
||||
x=mkt_data_df['tstamp'],
|
||||
y=norm_b,
|
||||
name=f'{SYMBOL_B} (Normalized)',
|
||||
line=dict(color='orange', width=2),
|
||||
opacity=0.8,
|
||||
),
|
||||
row=2, col=1
|
||||
)
|
||||
|
||||
# Add BUY and SELL signals if available
|
||||
if trades is not None and len(trades) > 0:
|
||||
# Define signal groups to avoid legend repetition
|
||||
signal_groups = {}
|
||||
|
||||
# Process all trades and group by signal type (ignore OPEN/CLOSE status)
|
||||
for _, trade in trades.iterrows():
|
||||
symbol = trade['symbol']
|
||||
side = trade['side']
|
||||
# status = trade['status']
|
||||
action = trade['action']
|
||||
|
||||
# Create signal group key (without status to combine OPEN/CLOSE)
|
||||
signal_key = f"{symbol} {side} {action}"
|
||||
|
||||
# Find normalized price for this trade
|
||||
trade_time = trade['time']
|
||||
if symbol == SYMBOL_A:
|
||||
closest_idx = mkt_data_df['tstamp'].searchsorted(trade_time)
|
||||
if closest_idx < len(norm_a):
|
||||
norm_price = norm_a.iloc[closest_idx]
|
||||
else:
|
||||
norm_price = norm_a.iloc[-1]
|
||||
else: # SYMBOL_B
|
||||
closest_idx = mkt_data_df['tstamp'].searchsorted(trade_time)
|
||||
if closest_idx < len(norm_b):
|
||||
norm_price = norm_b.iloc[closest_idx]
|
||||
else:
|
||||
norm_price = norm_b.iloc[-1]
|
||||
|
||||
# Initialize group if not exists
|
||||
if signal_key not in signal_groups:
|
||||
signal_groups[signal_key] = {
|
||||
'times': [],
|
||||
'prices': [],
|
||||
'actual_prices': [],
|
||||
'symbol': symbol,
|
||||
'side': side,
|
||||
# 'status': status,
|
||||
'action': trade['action']
|
||||
}
|
||||
|
||||
# Add to group
|
||||
signal_groups[signal_key]['times'].append(trade_time)
|
||||
signal_groups[signal_key]['prices'].append(norm_price)
|
||||
signal_groups[signal_key]['actual_prices'].append(trade['price'])
|
||||
|
||||
# Add each signal group as a single trace
|
||||
for signal_key, group_data in signal_groups.items():
|
||||
symbol = group_data['symbol']
|
||||
side = group_data['side']
|
||||
# status = group_data['status']
|
||||
|
||||
# Determine marker properties (same for all OPEN/CLOSE of same side)
|
||||
is_close: bool = (group_data['action'] == "CLOSE")
|
||||
|
||||
if 'BUY' in side:
|
||||
marker_color = 'green'
|
||||
marker_symbol = 'triangle-up'
|
||||
marker_size = 14
|
||||
else: # SELL
|
||||
marker_color = 'red'
|
||||
marker_symbol = 'triangle-down'
|
||||
marker_size = 14
|
||||
|
||||
# Create hover text for each point in the group
|
||||
hover_texts = []
|
||||
for i, (time, norm_price, actual_price) in enumerate(zip(group_data['times'],
|
||||
group_data['prices'],
|
||||
group_data['actual_prices'])):
|
||||
# Find the corresponding trade to get the status for hover text
|
||||
trade_info = trades[(trades['time'] == time) &
|
||||
(trades['symbol'] == symbol) &
|
||||
(trades['side'] == side)]
|
||||
if len(trade_info) > 0:
|
||||
action = trade_info.iloc[0]['action']
|
||||
hover_texts.append(f'<b>{signal_key} {action}</b><br>' +
|
||||
f'Time: {time}<br>' +
|
||||
f'Normalized Price: {norm_price:.4f}<br>' +
|
||||
f'Actual Price: ${actual_price:.2f}')
|
||||
else:
|
||||
hover_texts.append(f'<b>{signal_key}</b><br>' +
|
||||
f'Time: {time}<br>' +
|
||||
f'Normalized Price: {norm_price:.4f}<br>' +
|
||||
f'Actual Price: ${actual_price:.2f}')
|
||||
|
||||
fig.add_trace(
|
||||
go.Scatter(
|
||||
x=group_data['times'],
|
||||
y=group_data['prices'],
|
||||
mode='markers',
|
||||
name=signal_key,
|
||||
marker=dict(
|
||||
color=marker_color,
|
||||
size=marker_size,
|
||||
symbol=marker_symbol,
|
||||
line=dict(width=2, color='black') if is_close else None
|
||||
),
|
||||
showlegend=True,
|
||||
hovertemplate='%{text}<extra></extra>',
|
||||
text=hover_texts
|
||||
),
|
||||
row=2, col=1
|
||||
)
|
||||
|
||||
# -----------------------------
|
||||
|
||||
fig.add_trace(
|
||||
go.Scatter(
|
||||
x=symbol_a_data['tstamp'],
|
||||
y=symbol_a_data[colname_a],
|
||||
name=f'{SYMBOL_A} Price',
|
||||
line=dict(color='blue', width=2),
|
||||
opacity=0.8
|
||||
),
|
||||
row=3, col=1
|
||||
)
|
||||
|
||||
# Filter trades for Symbol_A
|
||||
symbol_a_trades = trades[trades['symbol'] == SYMBOL_A]
|
||||
print(f"\nSymbol_A trades:\n{symbol_a_trades}")
|
||||
|
||||
if len(symbol_a_trades) > 0:
|
||||
# Separate trades by action and status for different colors
|
||||
buy_open_trades = symbol_a_trades[(symbol_a_trades['side'].str.contains('BUY', na=False)) &
|
||||
(symbol_a_trades['action'].str.contains('OPEN', na=False))]
|
||||
buy_close_trades = symbol_a_trades[(symbol_a_trades['side'].str.contains('BUY', na=False)) &
|
||||
(symbol_a_trades['action'].str.contains('CLOSE', na=False))]
|
||||
|
||||
sell_open_trades = symbol_a_trades[(symbol_a_trades['side'].str.contains('SELL', na=False)) &
|
||||
(symbol_a_trades['action'].str.contains('OPEN', na=False))]
|
||||
sell_close_trades = symbol_a_trades[(symbol_a_trades['side'].str.contains('SELL', na=False)) &
|
||||
(symbol_a_trades['action'].str.contains('CLOSE', na=False))]
|
||||
|
||||
# Add BUY OPEN signals
|
||||
if len(buy_open_trades) > 0:
|
||||
fig.add_trace(
|
||||
go.Scatter(
|
||||
x=buy_open_trades['time'],
|
||||
y=buy_open_trades['price'],
|
||||
mode='markers',
|
||||
name=f'{SYMBOL_A} BUY OPEN',
|
||||
marker=dict(color='green', size=12, symbol='triangle-up'),
|
||||
showlegend=True
|
||||
),
|
||||
row=3, col=1
|
||||
)
|
||||
|
||||
# Add BUY CLOSE signals
|
||||
if len(buy_close_trades) > 0:
|
||||
fig.add_trace(
|
||||
go.Scatter(
|
||||
x=buy_close_trades['time'],
|
||||
y=buy_close_trades['price'],
|
||||
mode='markers',
|
||||
name=f'{SYMBOL_A} BUY CLOSE',
|
||||
marker=dict(color='green', size=12, symbol='triangle-up'),
|
||||
line=dict(width=2, color='black'),
|
||||
showlegend=True
|
||||
),
|
||||
row=3, col=1
|
||||
)
|
||||
|
||||
# Add SELL OPEN signals
|
||||
if len(sell_open_trades) > 0:
|
||||
fig.add_trace(
|
||||
go.Scatter(
|
||||
x=sell_open_trades['time'],
|
||||
y=sell_open_trades['price'],
|
||||
mode='markers',
|
||||
name=f'{SYMBOL_A} SELL OPEN',
|
||||
marker=dict(color='red', size=12, symbol='triangle-down'),
|
||||
showlegend=True
|
||||
),
|
||||
row=3, col=1
|
||||
)
|
||||
|
||||
# Add SELL CLOSE signals
|
||||
if len(sell_close_trades) > 0:
|
||||
fig.add_trace(
|
||||
go.Scatter(
|
||||
x=sell_close_trades['time'],
|
||||
y=sell_close_trades['price'],
|
||||
mode='markers',
|
||||
name=f'{SYMBOL_A} SELL CLOSE',
|
||||
marker=dict(color='red', size=12, symbol='triangle-down'),
|
||||
line=dict(width=2, color='black'),
|
||||
showlegend=True
|
||||
),
|
||||
row=3, col=1
|
||||
)
|
||||
|
||||
# 4. Symbol_B Market Data with Trading Signals
|
||||
fig.add_trace(
|
||||
go.Scatter(
|
||||
x=symbol_b_data['tstamp'],
|
||||
y=symbol_b_data[colname_b],
|
||||
name=f'{SYMBOL_B} Price',
|
||||
line=dict(color='orange', width=2),
|
||||
opacity=0.8
|
||||
),
|
||||
row=4, col=1
|
||||
)
|
||||
|
||||
# Add trading signals for Symbol_B if available
|
||||
symbol_b_trades = trades[trades['symbol'] == SYMBOL_B]
|
||||
print(f"\nSymbol_B trades:\n{symbol_b_trades}")
|
||||
|
||||
if len(symbol_b_trades) > 0:
|
||||
# Separate trades by action and status for different colors
|
||||
buy_open_trades = symbol_b_trades[(symbol_b_trades['side'].str.contains('BUY', na=False)) &
|
||||
(symbol_b_trades['action'].str.startswith('OPEN', na=False))]
|
||||
buy_close_trades = symbol_b_trades[(symbol_b_trades['side'].str.contains('BUY', na=False)) &
|
||||
(symbol_b_trades['action'].str.startswith('CLOSE', na=False))]
|
||||
|
||||
sell_open_trades = symbol_b_trades[(symbol_b_trades['side'].str.contains('SELL', na=False)) &
|
||||
(symbol_b_trades['action'].str.contains('OPEN', na=False))]
|
||||
sell_close_trades = symbol_b_trades[(symbol_b_trades['side'].str.contains('SELL', na=False)) &
|
||||
(symbol_b_trades['action'].str.contains('CLOSE', na=False))]
|
||||
|
||||
# Add BUY OPEN signals
|
||||
if len(buy_open_trades) > 0:
|
||||
fig.add_trace(
|
||||
go.Scatter(
|
||||
x=buy_open_trades['time'],
|
||||
y=buy_open_trades['price'],
|
||||
mode='markers',
|
||||
name=f'{SYMBOL_B} BUY OPEN',
|
||||
marker=dict(color='darkgreen', size=12, symbol='triangle-up'),
|
||||
showlegend=True
|
||||
),
|
||||
row=4, col=1
|
||||
)
|
||||
|
||||
# Add BUY CLOSE signals
|
||||
if len(buy_close_trades) > 0:
|
||||
fig.add_trace(
|
||||
go.Scatter(
|
||||
x=buy_close_trades['time'],
|
||||
y=buy_close_trades['price'],
|
||||
mode='markers',
|
||||
name=f'{SYMBOL_B} BUY CLOSE',
|
||||
marker=dict(color='green', size=12, symbol='triangle-up'),
|
||||
line=dict(width=2, color='black'),
|
||||
showlegend=True
|
||||
),
|
||||
row=4, col=1
|
||||
)
|
||||
|
||||
# Add SELL OPEN signals
|
||||
if len(sell_open_trades) > 0:
|
||||
fig.add_trace(
|
||||
go.Scatter(
|
||||
x=sell_open_trades['time'],
|
||||
y=sell_open_trades['price'],
|
||||
mode='markers',
|
||||
name=f'{SYMBOL_B} SELL OPEN',
|
||||
marker=dict(color='red', size=12, symbol='triangle-down'),
|
||||
showlegend=True
|
||||
),
|
||||
row=4, col=1
|
||||
)
|
||||
|
||||
# Add SELL CLOSE signals
|
||||
if len(sell_close_trades) > 0:
|
||||
fig.add_trace(
|
||||
go.Scatter(
|
||||
x=sell_close_trades['time'],
|
||||
y=sell_close_trades['price'],
|
||||
mode='markers',
|
||||
name=f'{SYMBOL_B} SELL CLOSE',
|
||||
marker=dict(color='red', size=12, symbol='triangle-down'),
|
||||
line=dict(width=2, color='black'),
|
||||
showlegend=True
|
||||
),
|
||||
row=4, col=1
|
||||
)
|
||||
|
||||
# Update layout
|
||||
fig.update_layout(
|
||||
height=1600,
|
||||
title_text=f"Strategy Analysis - {SYMBOL_A} & {SYMBOL_B} ({TRD_DATE})",
|
||||
showlegend=True,
|
||||
template="plotly_white",
|
||||
plot_bgcolor='lightgray',
|
||||
)
|
||||
|
||||
# Update y-axis labels
|
||||
fig.update_yaxes(title_text="Scaled Dis-equilibrium", row=1, col=1)
|
||||
fig.update_yaxes(title_text=f"{SYMBOL_A} Price ($)", row=2, col=1)
|
||||
fig.update_yaxes(title_text=f"{SYMBOL_B} Price ($)", row=3, col=1)
|
||||
fig.update_yaxes(title_text="Normalized Price (Base = 1.0)", row=4, col=1)
|
||||
|
||||
# Update x-axis labels and ensure consistent time range
|
||||
time_range = [timeline_df['tstamp'].min(), timeline_df['tstamp'].max()]
|
||||
fig.update_xaxes(range=time_range, row=1, col=1)
|
||||
fig.update_xaxes(range=time_range, row=2, col=1)
|
||||
fig.update_xaxes(range=time_range, row=3, col=1)
|
||||
fig.update_xaxes(title_text="Time", range=time_range, row=4, col=1)
|
||||
|
||||
# Display using plotly offline mode
|
||||
# pyo.iplot(fig)
|
||||
fig.show()
|
||||
|
||||
else:
|
||||
print("No interactive visualization data available - strategy may not have run successfully")
|
||||
|
||||
print(f"\nChart shows:")
|
||||
print(f"- {SYMBOL_A} and {SYMBOL_B} prices normalized to start at 1.0")
|
||||
print(f"- BUY signals shown as green triangles pointing up")
|
||||
print(f"- SELL signals shown as orange triangles pointing down")
|
||||
print(f"- All BUY signals per symbol grouped together, all SELL signals per symbol grouped together")
|
||||
print(f"- Hover over markers to see individual trade details (OPEN/CLOSE status)")
|
||||
|
||||
if trades is not None and len(trades) > 0:
|
||||
print(f"- Total signals displayed: {len(trades)}")
|
||||
print(f"- {SYMBOL_A} signals: {len(trades[trades['symbol'] == SYMBOL_A])}")
|
||||
print(f"- {SYMBOL_B} signals: {len(trades[trades['symbol'] == SYMBOL_B])}")
|
||||
else:
|
||||
print("- No trading signals to display")
|
||||
|
||||
Reference in New Issue
Block a user