unknown
1618 lines
83 KiB
Python
1618 lines
83 KiB
Python
"""
|
||
view_portfolio_builder.py — Portfolio Builder page for MT5 Tools
|
||
Tabs: Overview | Trades | Equity Chart | Strategies | Portfolios | What-If
|
||
"""
|
||
|
||
import streamlit as st
|
||
import pandas as pd
|
||
import numpy as np
|
||
import plotly.graph_objects as go
|
||
from plotly.subplots import make_subplots
|
||
import io, importlib, sys, os
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# Parser
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
def _get_parser():
|
||
if "mt5_parser" in sys.modules:
|
||
return importlib.reload(sys.modules["mt5_parser"])
|
||
import mt5_parser
|
||
return mt5_parser
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# Parse & normalise
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
def _parse_uploaded(file_obj):
|
||
try:
|
||
parser = _get_parser()
|
||
raw = file_obj.read()
|
||
result = parser.detect_and_parse(raw, file_obj.name)
|
||
return result[0] if isinstance(result, tuple) else result
|
||
except Exception as e:
|
||
st.error(f"Failed to parse **{file_obj.name}**: {e}")
|
||
return None
|
||
|
||
|
||
def _ensure_columns(df: pd.DataFrame, label: str) -> pd.DataFrame:
|
||
col_map = {}
|
||
|
||
def _first(targets, dest):
|
||
for c in targets:
|
||
if c in df.columns and dest not in col_map.values():
|
||
col_map[c] = dest
|
||
return
|
||
|
||
_first(["open_time","Open time","Open time ($)","Time"], "open_time")
|
||
_first(["close_time","Close time"], "close_time")
|
||
_first(["symbol","Symbol"], "symbol")
|
||
_first(["type","Type","Direction"], "type")
|
||
_first(["net_profit","P/L in money","Profit","profit"], "net_profit")
|
||
_first(["open_price","Open price","Price"], "open_price")
|
||
_first(["close_price","Close price"], "close_price")
|
||
_first(["volume","Volume","Size","size"], "volume")
|
||
_first(["commission","Commission"], "commission")
|
||
_first(["swap","Swap"], "swap")
|
||
_first(["comment","Comment"], "comment")
|
||
|
||
df = df.rename(columns=col_map)
|
||
|
||
if "net_profit" not in df.columns:
|
||
for c in ["profit","Profit","P/L"]:
|
||
if c in df.columns:
|
||
comm = pd.to_numeric(df.get("commission", 0), errors="coerce").fillna(0)
|
||
swap_ = pd.to_numeric(df.get("swap", 0), errors="coerce").fillna(0)
|
||
df["net_profit"] = pd.to_numeric(df[c], errors="coerce").fillna(0) + comm + swap_
|
||
break
|
||
|
||
for tc in ["open_time","close_time"]:
|
||
if tc in df.columns:
|
||
df[tc] = pd.to_datetime(df[tc], dayfirst=True, errors="coerce")
|
||
|
||
if "net_profit" in df.columns:
|
||
df["net_profit"] = pd.to_numeric(df["net_profit"], errors="coerce").fillna(0)
|
||
df["win"] = df["net_profit"] > 0
|
||
|
||
df["_strategy"] = label
|
||
df["_ea"] = label # EA = the uploaded filename stem
|
||
return df
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# Lot-size scaling — applies a multiplier to net_profit of a strategy copy
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
def _scale_df(df: pd.DataFrame, multiplier: float) -> pd.DataFrame:
|
||
"""Return a copy of df with net_profit scaled by multiplier."""
|
||
out = df.copy()
|
||
out["net_profit"] = out["net_profit"] * multiplier
|
||
if "win" in out.columns:
|
||
out["win"] = out["net_profit"] > 0
|
||
return out
|
||
|
||
|
||
def _get_effective_dfs(strategy_dfs: dict, lot_overrides: dict) -> dict:
|
||
"""Return strategy_dfs with lot-scaled copies substituted where overrides exist."""
|
||
result = {}
|
||
for label, df in strategy_dfs.items():
|
||
mult = lot_overrides.get(label, 1.0)
|
||
result[label] = _scale_df(df, mult) if mult != 1.0 else df
|
||
return result
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# Combine
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
def _combine(dfs_dict: dict, deposit: float) -> pd.DataFrame:
|
||
if not dfs_dict:
|
||
return pd.DataFrame()
|
||
combined = pd.concat([d.copy() for d in dfs_dict.values()], ignore_index=True)
|
||
if "close_time" in combined.columns:
|
||
combined = combined.sort_values("close_time").reset_index(drop=True)
|
||
if "net_profit" in combined.columns:
|
||
combined["equity"] = deposit + combined["net_profit"].cumsum()
|
||
return combined
|
||
|
||
|
||
def _get_active_df(view_mode: str, eff_dfs: dict, portfolios: dict, deposit: float):
|
||
if view_mode == "Portfolio (all)":
|
||
return _combine(eff_dfs, deposit), "Portfolio (all)"
|
||
if view_mode in portfolios:
|
||
members = {k: eff_dfs[k] for k in portfolios[view_mode] if k in eff_dfs}
|
||
return _combine(members, deposit), view_mode
|
||
if view_mode in eff_dfs:
|
||
df = eff_dfs[view_mode].copy()
|
||
if "close_time" in df.columns:
|
||
df = df.sort_values("close_time").reset_index(drop=True)
|
||
if "net_profit" in df.columns:
|
||
df["equity"] = deposit + df["net_profit"].cumsum()
|
||
return df, view_mode
|
||
return pd.DataFrame(), view_mode
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# Stats
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
def _calc_stats(df: pd.DataFrame, deposit: float) -> dict:
|
||
s = {}
|
||
if df.empty or "net_profit" not in df.columns:
|
||
return s
|
||
profits = df["net_profit"].fillna(0)
|
||
s["num_trades"] = len(df)
|
||
s["gross_profit"] = float(profits[profits > 0].sum())
|
||
s["gross_loss"] = float(profits[profits < 0].sum())
|
||
s["net_profit"] = float(profits.sum())
|
||
s["win_count"] = int((profits > 0).sum())
|
||
s["loss_count"] = int((profits <= 0).sum())
|
||
s["win_rate"] = s["win_count"] / s["num_trades"] * 100 if s["num_trades"] else 0
|
||
s["avg_win"] = float(profits[profits > 0].mean()) if s["win_count"] else 0
|
||
s["avg_loss"] = float(profits[profits < 0].mean()) if s["loss_count"] else 0
|
||
s["profit_factor"] = s["gross_profit"] / abs(s["gross_loss"]) if s["gross_loss"] else float("inf")
|
||
s["avg_trade"] = float(profits.mean())
|
||
|
||
# Avg lot size
|
||
if "volume" in df.columns:
|
||
s["avg_lot"] = float(pd.to_numeric(df["volume"], errors="coerce").mean())
|
||
else:
|
||
s["avg_lot"] = 0.0
|
||
|
||
eq = deposit + profits.cumsum()
|
||
rm = eq.cummax()
|
||
dd = eq - rm
|
||
s["max_dd"] = float(dd.min())
|
||
s["max_dd_pct"] = float(dd.min() / deposit * 100)
|
||
s["ret_dd_ratio"] = s["net_profit"] / abs(s["max_dd"]) if s["max_dd"] else 0
|
||
|
||
ws = (profits > 0).astype(int).tolist()
|
||
cw = cl = mcw = mcl = 0
|
||
for w in ws:
|
||
if w: cw += 1; cl = 0
|
||
else: cl += 1; cw = 0
|
||
mcw = max(mcw, cw); mcl = max(mcl, cl)
|
||
s["max_consec_wins"] = mcw
|
||
s["max_consec_losses"] = mcl
|
||
|
||
if "close_time" in df.columns:
|
||
vc = df["close_time"].dropna()
|
||
vo = df["open_time"].dropna() if "open_time" in df.columns else vc
|
||
if not vc.empty:
|
||
s["start_date"] = vo.min() if not vo.empty else vc.min()
|
||
s["end_date"] = vc.max()
|
||
days = max((s["end_date"] - s["start_date"]).days, 1)
|
||
s["years"] = days / 365.25
|
||
s["yearly_avg_profit"] = s["net_profit"] / s["years"]
|
||
s["monthly_avg_profit"] = s["net_profit"] / max(days / 30.44, 1)
|
||
s["cagr"] = ((deposit + s["net_profit"]) / deposit) ** (1 / s["years"]) - 1
|
||
|
||
if "close_time" in df.columns:
|
||
eq_ts = df[["close_time","net_profit"]].dropna().sort_values("close_time").copy()
|
||
if not eq_ts.empty:
|
||
eq_ts["cum"] = deposit + eq_ts["net_profit"].cumsum()
|
||
eq_ts["date"] = eq_ts["close_time"].dt.date
|
||
dly = eq_ts.groupby("date")["cum"].last().reset_index()
|
||
peak = float(dly["cum"].iloc[0]); stag_start = dly["date"].iloc[0]; max_stag = 0
|
||
for _, r in dly.iterrows():
|
||
if float(r["cum"]) > peak:
|
||
peak = float(r["cum"]); stag_start = r["date"]
|
||
else:
|
||
max_stag = max(max_stag, (r["date"] - stag_start).days)
|
||
s["max_stagnation_days"] = max_stag
|
||
|
||
# Monthly tables — both $ and %
|
||
if "close_time" in df.columns:
|
||
mdf = df[["close_time","net_profit"]].dropna().copy()
|
||
mdf["year"] = mdf["close_time"].dt.year
|
||
mdf["month"] = mdf["close_time"].dt.month
|
||
monthly = mdf.groupby(["year","month"])["net_profit"].sum().reset_index()
|
||
pivot_d = monthly.pivot(index="year", columns="month", values="net_profit").fillna(0)
|
||
pivot_d.columns = [pd.Timestamp(2000, int(m), 1).strftime("%b") for m in pivot_d.columns]
|
||
pivot_d["YTD"] = pivot_d.sum(axis=1)
|
||
s["monthly_table_dollar"] = pivot_d
|
||
|
||
# % — each month relative to deposit
|
||
pivot_p = pivot_d.copy()
|
||
for col in pivot_p.columns:
|
||
pivot_p[col] = pivot_p[col] / deposit * 100
|
||
s["monthly_table_pct"] = pivot_p
|
||
|
||
return s
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# Portfolio comparison — correlation across bucketed P&L series
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
def _bucket_pnl(df: pd.DataFrame, mode: str, time_col: str = "close_time") -> pd.Series:
|
||
"""
|
||
Aggregate net_profit into a time-bucketed series for correlation analysis.
|
||
|
||
mode:
|
||
- "daily" — sum P&L per calendar day
|
||
- "weekly" — sum P&L per ISO week
|
||
- "monthly" — sum P&L per calendar month
|
||
- "close_hour" — sum P&L per hour bucket of close_time (1-hour windows)
|
||
- "open_hour" — sum P&L per hour bucket of open_time
|
||
- "trade" — one row per trade keyed by close_time (no aggregation)
|
||
|
||
Returns a Series indexed by the bucket key with summed net_profit.
|
||
"""
|
||
if df.empty or "net_profit" not in df.columns:
|
||
return pd.Series(dtype=float)
|
||
|
||
if mode == "open_hour":
|
||
time_col = "open_time"
|
||
elif mode == "close_hour":
|
||
time_col = "close_time"
|
||
|
||
if time_col not in df.columns:
|
||
return pd.Series(dtype=float)
|
||
|
||
times = pd.to_datetime(df[time_col], errors="coerce")
|
||
profits = pd.to_numeric(df["net_profit"], errors="coerce").fillna(0)
|
||
valid = times.notna()
|
||
times, profits = times[valid], profits[valid]
|
||
if times.empty:
|
||
return pd.Series(dtype=float)
|
||
|
||
if mode == "daily":
|
||
key = times.dt.normalize()
|
||
elif mode == "weekly":
|
||
key = times.dt.to_period("W").apply(lambda p: p.start_time)
|
||
elif mode == "monthly":
|
||
key = times.dt.to_period("M").apply(lambda p: p.start_time)
|
||
elif mode in ("close_hour", "open_hour"):
|
||
# Truncate to the hour — trades closing/opening within the same 1-hour
|
||
# window get bucketed together.
|
||
key = times.dt.floor("h")
|
||
elif mode == "trade":
|
||
# Each trade is its own row, indexed by exact close time
|
||
return pd.Series(profits.values, index=times.values).sort_index()
|
||
else:
|
||
key = times.dt.normalize()
|
||
|
||
return profits.groupby(key).sum().sort_index()
|
||
|
||
|
||
def _portfolio_pnl_series(portfolio_name: str, portfolios: dict, eff_dfs: dict,
|
||
mode: str) -> pd.Series:
|
||
"""Build a bucketed P&L series for a named portfolio (or 'Portfolio (all)')."""
|
||
if portfolio_name == "Portfolio (all)":
|
||
members = list(eff_dfs.keys())
|
||
else:
|
||
members = portfolios.get(portfolio_name, [])
|
||
member_dfs = [eff_dfs[m] for m in members if m in eff_dfs]
|
||
if not member_dfs:
|
||
return pd.Series(dtype=float)
|
||
combined = pd.concat(member_dfs, ignore_index=True)
|
||
return _bucket_pnl(combined, mode)
|
||
|
||
|
||
def _correlation_matrix(series_dict: dict, method: str = "pearson") -> pd.DataFrame:
|
||
"""
|
||
Compute correlation matrix across portfolio P&L series.
|
||
Series are aligned on the union of bucket keys; missing buckets fill 0
|
||
(i.e. a portfolio that didn't trade in that bucket contributed $0 P&L).
|
||
"""
|
||
if not series_dict:
|
||
return pd.DataFrame()
|
||
aligned = pd.concat(series_dict, axis=1).fillna(0)
|
||
if aligned.shape[1] < 2:
|
||
return pd.DataFrame()
|
||
return aligned.corr(method=method)
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# Chart helpers
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
COLORS = ["#4C8EF5","#F5A623","#7ED321","#BD10E0",
|
||
"#9B59B6","#1ABC9C","#E67E22","#FF6B9D"]
|
||
|
||
|
||
def _smooth(y: pd.Series, window: int) -> pd.Series:
|
||
if window <= 1:
|
||
return y
|
||
return y.rolling(window=window, min_periods=1, center=True).mean()
|
||
|
||
|
||
def _add_stagnation_vrect(fig, df: pd.DataFrame, deposit: float):
|
||
eq_ts = df[["close_time","net_profit"]].dropna().sort_values("close_time").copy()
|
||
if eq_ts.empty:
|
||
return
|
||
eq_ts["cum"] = deposit + eq_ts["net_profit"].cumsum()
|
||
peak = float(eq_ts["cum"].iloc[0]); stag_start = eq_ts["close_time"].iloc[0]
|
||
max_days = 0; best_s = stag_start; best_e = stag_start
|
||
for _, r in eq_ts.iterrows():
|
||
if float(r["cum"]) > peak:
|
||
days = (r["close_time"] - stag_start).days
|
||
if days > max_days:
|
||
max_days = days; best_s = stag_start; best_e = r["close_time"]
|
||
peak = float(r["cum"]); stag_start = r["close_time"]
|
||
if max_days > 0:
|
||
fig.add_vrect(x0=best_s, x1=best_e,
|
||
fillcolor="rgba(255,160,80,0.10)", line_width=0,
|
||
annotation_text=f"Max stagnation: {max_days}d",
|
||
annotation_position="top left",
|
||
annotation_font_size=11, annotation_font_color="#FFB366",
|
||
row=1, col=1)
|
||
|
||
|
||
def _build_equity_chart(
|
||
df: pd.DataFrame, deposit: float,
|
||
eff_dfs: dict, portfolios: dict, active_label: str,
|
||
chart_view: str, smooth_window: int,
|
||
show_stagnation: bool,
|
||
date_from, date_to,
|
||
selected_strategies: list,
|
||
selected_portfolio: str = None,
|
||
):
|
||
fig = make_subplots(
|
||
rows=3, cols=1, shared_xaxes=True,
|
||
row_heights=[0.62, 0.19, 0.19],
|
||
vertical_spacing=0.02,
|
||
subplot_titles=("", "Drawdown from Peak ($)", "Daily P&L ($)"),
|
||
)
|
||
all_dd_frames = []
|
||
all_daily_frames = []
|
||
|
||
# Compute the global time span across all series being plotted so every
|
||
# line can be extended to span the full x-axis width.
|
||
_all_times = []
|
||
for _sdf in eff_dfs.values():
|
||
if "close_time" in _sdf.columns:
|
||
_all_times.append(pd.to_datetime(_sdf["close_time"]).dt.tz_localize(None).dropna())
|
||
if not df.empty and "close_time" in df.columns:
|
||
_all_times.append(pd.to_datetime(df["close_time"]).dt.tz_localize(None).dropna())
|
||
_global_min = min(s.min() for s in _all_times) if _all_times else None
|
||
_global_max = max(s.max() for s in _all_times) if _all_times else None
|
||
# Clamp to date filter if set
|
||
if date_from and _global_min is not None:
|
||
_global_min = max(_global_min, pd.Timestamp(date_from))
|
||
if date_to and _global_max is not None:
|
||
_global_max = min(_global_max, pd.Timestamp(date_to) + pd.Timedelta(days=1))
|
||
|
||
def _plot_series(times: pd.Series, profits: pd.Series,
|
||
name: str, color: str, width: float):
|
||
times = times.reset_index(drop=True)
|
||
profits = profits.reset_index(drop=True)
|
||
eq_full = deposit + profits.cumsum()
|
||
rm_full = eq_full.cummax()
|
||
dd_full = eq_full - rm_full
|
||
|
||
times_dt = pd.to_datetime(times).dt.tz_localize(None)
|
||
mask = pd.Series([True] * len(times_dt), dtype=bool)
|
||
if date_from:
|
||
mask &= times_dt >= pd.Timestamp(date_from)
|
||
if date_to:
|
||
mask &= times_dt <= pd.Timestamp(date_to) + pd.Timedelta(days=1)
|
||
|
||
times_f = times_dt[mask].reset_index(drop=True)
|
||
eq_f = eq_full[mask].reset_index(drop=True)
|
||
dd_f = dd_full[mask].reset_index(drop=True)
|
||
if eq_f.empty:
|
||
return
|
||
|
||
all_dd_frames.append(pd.DataFrame({"t": times_f, "dd": dd_f}))
|
||
|
||
# Daily P&L — sum net_profit per day within the filtered window
|
||
profits_f = profits[mask].reset_index(drop=True)
|
||
daily_pnl = (pd.DataFrame({"t": times_f, "pnl": profits_f})
|
||
.assign(date=lambda x: x["t"].dt.normalize())
|
||
.groupby("date")["pnl"].sum()
|
||
.reset_index()
|
||
.rename(columns={"date": "t"}))
|
||
all_daily_frames.append(daily_pnl)
|
||
|
||
eq_disp = _smooth(eq_f, smooth_window)
|
||
|
||
# Extend line to global span so all series fill the full x-axis
|
||
if _global_min is not None and len(times_f) > 0 and times_f.iloc[0] > _global_min:
|
||
times_f = pd.concat([pd.Series([_global_min]), times_f], ignore_index=True)
|
||
eq_disp = pd.concat([pd.Series([eq_disp.iloc[0]]), eq_disp], ignore_index=True)
|
||
if _global_max is not None and len(times_f) > 0 and times_f.iloc[-1] < _global_max:
|
||
times_f = pd.concat([times_f, pd.Series([_global_max])], ignore_index=True)
|
||
eq_disp = pd.concat([eq_disp, pd.Series([eq_disp.iloc[-1]])], ignore_index=True)
|
||
|
||
fig.add_trace(go.Scatter(
|
||
x=times_f, y=eq_disp, name=name,
|
||
line=dict(color=color, width=width), mode="lines",
|
||
connectgaps=True,
|
||
hovertemplate=f"<b>{name}</b><br>%{{x|%d %b %Y}}<br>${{y:,.2f}}<extra></extra>",
|
||
), row=1, col=1)
|
||
|
||
if chart_view == "Portfolio":
|
||
# Show the selected portfolio / all as one combined line
|
||
if not df.empty and "close_time" in df.columns and "net_profit" in df.columns:
|
||
_plot_series(df["close_time"], df["net_profit"], active_label, COLORS[0], 2.0)
|
||
if show_stagnation:
|
||
_add_stagnation_vrect(fig, df, deposit)
|
||
|
||
elif chart_view == "Portfolio+Individual":
|
||
# Combined line + each member underneath
|
||
if not df.empty and "close_time" in df.columns and "net_profit" in df.columns:
|
||
import os as _os, re as _re2
|
||
_cfg = _os.path.join(_os.path.dirname(_os.path.abspath(__file__)), ".streamlit", "config.toml")
|
||
_light = False
|
||
if _os.path.isfile(_cfg):
|
||
_m = _re2.search(r'base\s*=\s*"([^"]*)"', open(_cfg).read())
|
||
if _m: _light = _m.group(1) == "light"
|
||
_portfolio_color = "#1a3a5c" if _light else "#FFFFFF"
|
||
_plot_series(df["close_time"], df["net_profit"], f"{active_label} (combined)",
|
||
_portfolio_color, 2.5)
|
||
if show_stagnation:
|
||
_add_stagnation_vrect(fig, df, deposit)
|
||
for i, label in enumerate(selected_strategies):
|
||
if label not in eff_dfs:
|
||
continue
|
||
sdf = eff_dfs[label]
|
||
if "close_time" not in sdf.columns or "net_profit" not in sdf.columns:
|
||
continue
|
||
sdf_s = sdf.sort_values("close_time")
|
||
_plot_series(sdf_s["close_time"], sdf_s["net_profit"],
|
||
label, COLORS[i % len(COLORS)], 1.2)
|
||
|
||
else: # Individual
|
||
for i, label in enumerate(selected_strategies):
|
||
if label not in eff_dfs:
|
||
continue
|
||
sdf = eff_dfs[label]
|
||
if "close_time" not in sdf.columns or "net_profit" not in sdf.columns:
|
||
continue
|
||
sdf_s = sdf.sort_values("close_time")
|
||
_plot_series(sdf_s["close_time"], sdf_s["net_profit"],
|
||
label, COLORS[i % len(COLORS)], 1.5)
|
||
|
||
# Row 2 — cumulative drawdown from peak
|
||
if all_dd_frames:
|
||
dd_all = pd.concat(all_dd_frames).sort_values("t").reset_index(drop=True)
|
||
dd_agg = dd_all.groupby("t")["dd"].min().reset_index()
|
||
fig.add_trace(go.Scatter(
|
||
x=dd_agg["t"], y=dd_agg["dd"],
|
||
name="Peak DD", fill="tozeroy",
|
||
fillcolor="rgba(220,50,50,0.30)",
|
||
line=dict(color="rgba(220,50,50,0.75)", width=1),
|
||
mode="lines", showlegend=False,
|
||
hovertemplate="Peak DD: $%{y:,.2f}<extra></extra>",
|
||
), row=2, col=1)
|
||
|
||
# Row 3 — daily P&L bars
|
||
if all_daily_frames:
|
||
daily_all = pd.concat(all_daily_frames).groupby("t")["pnl"].sum().reset_index()
|
||
pos = daily_all["pnl"].clip(lower=0)
|
||
neg = daily_all["pnl"].clip(upper=0)
|
||
# Green bars for positive days
|
||
fig.add_trace(go.Bar(
|
||
x=daily_all["t"], y=pos,
|
||
name="Daily gain",
|
||
marker_color="rgba(52,194,122,0.70)",
|
||
showlegend=False,
|
||
hovertemplate="Daily P&L: $%{y:,.2f}<extra></extra>",
|
||
), row=3, col=1)
|
||
# Red bars for negative days
|
||
fig.add_trace(go.Bar(
|
||
x=daily_all["t"], y=neg,
|
||
name="Daily loss",
|
||
marker_color="rgba(220,50,50,0.70)",
|
||
showlegend=False,
|
||
hovertemplate="Daily P&L: $%{y:,.2f}<extra></extra>",
|
||
), row=3, col=1)
|
||
|
||
fig.update_layout(
|
||
height=1240, margin=dict(l=60,r=20,t=24,b=10),
|
||
paper_bgcolor="rgba(0,0,0,0)", plot_bgcolor="rgba(0,0,0,0)",
|
||
legend=dict(orientation="h", yanchor="bottom", y=1.02,
|
||
xanchor="left", x=0, font=dict(size=11)),
|
||
hovermode="x unified", bargap=0, barmode="overlay",
|
||
hoverlabel=dict(namelength=-1, font=dict(size=11)),
|
||
)
|
||
# Force x-axis range to match the selected date window
|
||
x_min = pd.Timestamp(date_from) if date_from else None
|
||
x_max = pd.Timestamp(date_to) + pd.Timedelta(days=1) if date_to else None
|
||
|
||
fig.update_xaxes(
|
||
gridcolor="rgba(128,128,128,0.15)", zeroline=False,
|
||
showspikes=True, spikecolor="#445", spikethickness=1,
|
||
range=[x_min, x_max] if x_min and x_max else None,
|
||
)
|
||
fig.update_yaxes(gridcolor="rgba(128,128,128,0.15)", zeroline=False)
|
||
fig.update_yaxes(title_text="Equity ($)", row=1, col=1, tickprefix="$")
|
||
fig.update_yaxes(title_text="Peak DD ($)", row=2, col=1, tickprefix="$")
|
||
fig.update_yaxes(title_text="Daily P&L ($)", row=3, col=1, tickprefix="$")
|
||
for ann in fig.layout.annotations:
|
||
ann.font.size = 11
|
||
ann.font.color = "#6C7A8D"
|
||
return fig
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# Monthly HTML table (supports $ or %)
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
def _monthly_html(pivot: pd.DataFrame, mode: str = "$") -> str:
|
||
order = ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec","YTD"]
|
||
cols = [c for c in order if c in pivot.columns]
|
||
pivot = pivot[cols]
|
||
rows = []
|
||
for year, row in pivot.iterrows():
|
||
cells = [f"<td class='yc'>{year}</td>"]
|
||
for col in cols:
|
||
v = row.get(col, 0)
|
||
if pd.isna(v) or v == 0:
|
||
cls = "z"
|
||
txt = "0"
|
||
elif v > 0:
|
||
cls = "p"
|
||
txt = f"{v:,.2f}%" if mode == "%" else f"{v:,.2f}"
|
||
else:
|
||
cls = "n"
|
||
txt = f"{v:,.2f}%" if mode == "%" else f"{v:,.2f}"
|
||
cells.append(f"<td class='{cls}'>{txt}</td>")
|
||
rows.append("<tr>" + "".join(cells) + "</tr>")
|
||
hdr = "<tr><th>Year</th>" + "".join(f"<th>{c}</th>" for c in cols) + "</tr>"
|
||
return (
|
||
"<style>.mt{width:100%;border-collapse:collapse;font-size:12px;"
|
||
"font-family:'Courier New',monospace}"
|
||
".mt .p{color:#34C27A}.mt .n{color:#E05555}</style>"
|
||
f"<table class='mt'><thead>{hdr}</thead><tbody>{''.join(rows)}</tbody></table>"
|
||
)
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# Strategy comparison table
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
def _strategy_table(eff_dfs: dict, deposit: float, lot_overrides: dict) -> pd.DataFrame:
|
||
rows = []
|
||
for label, df in eff_dfs.items():
|
||
s = _calc_stats(df, deposit)
|
||
pf = s.get("profit_factor", 0)
|
||
mult = lot_overrides.get(label, 1.0)
|
||
# Avg lot from original (unscaled) volume; if scaled show effective avg
|
||
base_avg_lot = s.get("avg_lot", 0.0)
|
||
rows.append({
|
||
"Strategy": label,
|
||
"Lot ×": round(mult, 2),
|
||
"Avg Lot": round(base_avg_lot, 4),
|
||
"Trades": s.get("num_trades", 0),
|
||
"Net Profit ($)": round(s.get("net_profit", 0), 2),
|
||
"Win Rate (%)": round(s.get("win_rate", 0), 2),
|
||
"Profit Factor": round(pf, 2) if pf != float("inf") else 999.0,
|
||
"Max DD ($)": round(s.get("max_dd", 0), 2),
|
||
"Max DD (%)": round(s.get("max_dd_pct", 0), 2),
|
||
"Ret/DD": round(s.get("ret_dd_ratio", 0), 2),
|
||
"Avg Trade ($)": round(s.get("avg_trade", 0), 2),
|
||
"Stagnation (d)": s.get("max_stagnation_days", 0),
|
||
"Start": str(s.get("start_date",""))[:10],
|
||
"End": str(s.get("end_date",""))[:10],
|
||
})
|
||
return pd.DataFrame(rows)
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# Session state
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
def _init_state():
|
||
for k, v in {
|
||
"pb_uploaded_files": {},
|
||
"pb_portfolios": {},
|
||
"pb_lot_overrides": {}, # label → float multiplier
|
||
"pb_deposit": 10000.0,
|
||
"pb_n_slots": 5, # number of file upload slots shown
|
||
}.items():
|
||
if k not in st.session_state:
|
||
st.session_state[k] = v
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# Render
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
def render():
|
||
_init_state()
|
||
|
||
# Card/stat styling injected globally by inject_theme_css() in app.py
|
||
# Also expand multiselect tags so full strategy names are visible
|
||
st.markdown("""<style>
|
||
span[data-baseweb="tag"] { max-width: none !important; }
|
||
span[data-baseweb="tag"] span { max-width: none !important; overflow: visible !important;
|
||
white-space: normal !important; text-overflow: unset !important; }
|
||
</style>""", unsafe_allow_html=True)
|
||
|
||
st.markdown('<p class="pb-title">📊 Portfolio Builder</p>', unsafe_allow_html=True)
|
||
st.markdown('<p class="pb-sub">Combine MT5 backtest reports into multi-strategy portfolios</p>',
|
||
unsafe_allow_html=True)
|
||
|
||
# ── Upload panel ─────────────────────────────────────────────────────────
|
||
with st.expander("📂 Load Strategy Reports",
|
||
expanded=not bool(st.session_state.pb_uploaded_files)):
|
||
|
||
load_mode = st.radio(
|
||
"Load method",
|
||
["📁 Upload files", "🗂 Scan folder"],
|
||
horizontal=True, key="pb_load_mode",
|
||
)
|
||
|
||
if load_mode == "📁 Upload files":
|
||
st.caption("Select one or more `.htm` · `.html` · `.csv` files — hold Ctrl/Cmd to pick multiple.")
|
||
uploaded_files = st.file_uploader(
|
||
"Strategy reports",
|
||
type=["htm", "html", "csv"],
|
||
accept_multiple_files=True,
|
||
key="pb_multi_uploader",
|
||
label_visibility="collapsed",
|
||
)
|
||
if uploaded_files:
|
||
added = 0
|
||
for f in uploaded_files:
|
||
stem = os.path.splitext(f.name)[0]
|
||
if stem not in st.session_state.pb_uploaded_files:
|
||
df = _parse_uploaded(f)
|
||
if df is not None:
|
||
df = _ensure_columns(df, stem)
|
||
st.session_state.pb_uploaded_files[stem] = df
|
||
added += 1
|
||
if added:
|
||
st.success(f"✅ Loaded {added} file(s)")
|
||
st.rerun()
|
||
|
||
else: # Scan folder
|
||
st.caption("Enter a folder path — all `.htm` / `.html` / `.csv` files inside will be loaded.")
|
||
fp_col, sub_col = st.columns([4, 1])
|
||
folder_path = fp_col.text_input(
|
||
"Folder path",
|
||
placeholder=r"e.g. C:\MT5\Reports\Backtest",
|
||
key="pb_folder_path",
|
||
label_visibility="collapsed",
|
||
)
|
||
include_sub = sub_col.checkbox("Subfolders", value=False, key="pb_folder_sub")
|
||
|
||
if st.button("📂 Scan & Load", key="pb_scan_btn", type="primary"):
|
||
if not folder_path or not os.path.isdir(folder_path):
|
||
st.error("Folder not found — check the path and try again.")
|
||
else:
|
||
import glob as _glob
|
||
exts = ("*.htm", "*.html", "*.csv")
|
||
found = []
|
||
for ext in exts:
|
||
pattern = os.path.join(folder_path, "**", ext) if include_sub \
|
||
else os.path.join(folder_path, ext)
|
||
found.extend(_glob.glob(pattern, recursive=include_sub))
|
||
found = sorted(set(found))
|
||
|
||
if not found:
|
||
st.warning("No `.htm` / `.html` / `.csv` files found in that folder.")
|
||
else:
|
||
added = skipped = errors = 0
|
||
for fpath in found:
|
||
stem = os.path.splitext(os.path.basename(fpath))[0]
|
||
if stem in st.session_state.pb_uploaded_files:
|
||
skipped += 1
|
||
continue
|
||
try:
|
||
with open(fpath, "rb") as fh:
|
||
raw = fh.read()
|
||
parser = _get_parser()
|
||
result = parser.detect_and_parse(raw, os.path.basename(fpath))
|
||
df = result[0] if isinstance(result, tuple) else result
|
||
if df is not None:
|
||
df = _ensure_columns(df, stem)
|
||
st.session_state.pb_uploaded_files[stem] = df
|
||
added += 1
|
||
except Exception as e:
|
||
st.warning(f"Could not load **{stem}**: {e}")
|
||
errors += 1
|
||
|
||
parts = [f"✅ {added} loaded"]
|
||
if skipped: parts.append(f"{skipped} already present")
|
||
if errors: parts.append(f"{errors} failed")
|
||
st.success(" · ".join(parts))
|
||
if added:
|
||
st.rerun()
|
||
|
||
if st.session_state.pb_uploaded_files:
|
||
st.markdown("---")
|
||
st.markdown(f"**{len(st.session_state.pb_uploaded_files)} strategies loaded:**")
|
||
to_remove = []
|
||
for label in list(st.session_state.pb_uploaded_files):
|
||
c1, c2 = st.columns([6, 1])
|
||
c1.markdown(f"<span class='chip'>📈 {label}</span>",
|
||
unsafe_allow_html=True)
|
||
if c2.button("✕", key=f"rm_{label}"):
|
||
to_remove.append(label)
|
||
for k in to_remove:
|
||
del st.session_state.pb_uploaded_files[k]
|
||
st.session_state.pb_lot_overrides.pop(k, None)
|
||
for pn in st.session_state.pb_portfolios:
|
||
if k in st.session_state.pb_portfolios[pn]:
|
||
st.session_state.pb_portfolios[pn].remove(k)
|
||
st.rerun()
|
||
|
||
strategy_dfs: dict = st.session_state.pb_uploaded_files
|
||
portfolios: dict = st.session_state.pb_portfolios
|
||
lot_overrides: dict = st.session_state.pb_lot_overrides
|
||
|
||
if not strategy_dfs:
|
||
st.info("Upload one or more strategy reports above to get started.")
|
||
return
|
||
|
||
# Effective DFs (with lot scaling applied)
|
||
eff_dfs = _get_effective_dfs(strategy_dfs, lot_overrides)
|
||
|
||
# ── View selector + deposit ───────────────────────────────────────────────
|
||
view_options = (["Portfolio (all)"]
|
||
+ [f"Portfolio: {p}" for p in portfolios]
|
||
+ list(strategy_dfs.keys()))
|
||
label_map = {"Portfolio (all)": "Portfolio (all)"}
|
||
for p in portfolios: label_map[f"Portfolio: {p}"] = p
|
||
for s in strategy_dfs: label_map[s] = s
|
||
|
||
sc1, sc2 = st.columns([4, 2])
|
||
view_sel = sc1.selectbox("View", view_options, key="pb_view_sel")
|
||
deposit = sc2.number_input("Initial Deposit ($)", min_value=100.0,
|
||
max_value=10_000_000.0,
|
||
value=st.session_state.pb_deposit,
|
||
step=1000.0, format="%.2f",
|
||
key="pb_deposit_input")
|
||
st.session_state.pb_deposit = deposit
|
||
|
||
view_mode = label_map.get(view_sel, view_sel)
|
||
df, active_label = _get_active_df(view_mode, eff_dfs, portfolios, deposit)
|
||
|
||
# ── Shared date-range slider (used by Overview + Trades) ───────────────────────────
|
||
import datetime as _dt
|
||
_has_dates = not df.empty and "close_time" in df.columns
|
||
if _has_dates:
|
||
_all_dates = pd.to_datetime(df["close_time"]).dt.tz_localize(None).dropna()
|
||
_gmin = _all_dates.min().date()
|
||
_gmax = _all_dates.max().date()
|
||
_total_days = (_gmax - _gmin).days
|
||
_step = max(1, _total_days // 500)
|
||
_date_options = [_gmin + _dt.timedelta(days=i)
|
||
for i in range(0, _total_days + 1, _step)]
|
||
if _date_options[-1] != _gmax:
|
||
_date_options.append(_gmax)
|
||
else:
|
||
_gmin = _gmax = None
|
||
_date_options = []
|
||
|
||
def _date_slider(key_prefix):
|
||
if not _has_dates or _gmin == _gmax or len(_date_options) < 2:
|
||
return _gmin, _gmax
|
||
skey = f"{key_prefix}_dslider"
|
||
# Use existing session state value if valid, otherwise default to full range
|
||
existing = st.session_state.get(skey)
|
||
if (existing and isinstance(existing, (list, tuple)) and len(existing) == 2
|
||
and existing[0] in _date_options and existing[1] in _date_options):
|
||
default_val = (existing[0], existing[1])
|
||
else:
|
||
default_val = (_gmin, _gmax)
|
||
sel = st.select_slider(
|
||
"Date range",
|
||
options=_date_options,
|
||
value=default_val,
|
||
format_func=lambda d: d.strftime("%d %b %Y"),
|
||
key=skey,
|
||
)
|
||
return sel[0], sel[1]
|
||
|
||
|
||
# ── Overview filters (only shown for multi-strategy views) ───────────────
|
||
# Determine if this is a portfolio/all view with multiple strategies
|
||
_is_multi = view_mode in ("Portfolio (all)",) or view_mode in portfolios
|
||
ov_df = df # default — filtered below if _is_multi
|
||
|
||
if not df.empty:
|
||
ov_date_from, ov_date_to = _date_slider("pb_ov")
|
||
|
||
strat_labels = sorted(df["_strategy"].dropna().unique().tolist()) \
|
||
if "_strategy" in df.columns else []
|
||
sym_labels = sorted(df["symbol"].dropna().unique().tolist()) \
|
||
if "symbol" in df.columns else []
|
||
|
||
if _is_multi:
|
||
# EA filter (file level)
|
||
ea_labels = sorted(df["_ea"].dropna().unique().tolist()) \
|
||
if "_ea" in df.columns else strat_labels
|
||
fc1, fc2, fc3 = st.columns(3)
|
||
sel_eas = fc1.multiselect(
|
||
"Filter EA",
|
||
ea_labels, default=ea_labels, key="pb_ov_ea",
|
||
help="Filter by uploaded file (EA)",
|
||
)
|
||
# Strategy filter — cascades from EA selection
|
||
if "_ea" in df.columns and sel_eas:
|
||
strat_labels_filtered = sorted(
|
||
df[df["_ea"].isin(sel_eas)]["strategy"].dropna().unique().tolist()
|
||
) if "strategy" in df.columns else strat_labels
|
||
else:
|
||
strat_labels_filtered = strat_labels
|
||
sel_strats_raw = fc2.multiselect(
|
||
"Filter Strategy",
|
||
strat_labels_filtered, default=strat_labels_filtered, key="pb_ov_strat",
|
||
help="Filter by strategy (comment) within selected EAs",
|
||
)
|
||
sel_syms = fc3.multiselect(
|
||
"Filter symbols",
|
||
sym_labels, default=sym_labels, key="pb_ov_sym",
|
||
)
|
||
else:
|
||
sel_strats_raw = strat_labels
|
||
sel_syms = sym_labels
|
||
|
||
ov_df = df.copy()
|
||
if "close_time" in ov_df.columns and ov_date_from and ov_date_to:
|
||
ct = pd.to_datetime(ov_df["close_time"]).dt.tz_localize(None)
|
||
ov_df = ov_df[
|
||
(ct >= pd.Timestamp(ov_date_from)) &
|
||
(ct <= pd.Timestamp(ov_date_to) + pd.Timedelta(days=1))
|
||
]
|
||
if sel_strats_raw and "strategy" in ov_df.columns:
|
||
ov_df = ov_df[ov_df["strategy"].isin(sel_strats_raw)]
|
||
if sel_syms and "symbol" in ov_df.columns:
|
||
ov_df = ov_df[ov_df["symbol"].isin(sel_syms)]
|
||
|
||
stats = _calc_stats(ov_df, deposit)
|
||
|
||
# ── Tabs ─────────────────────────────────────────────────────────────────
|
||
tab_ov, tab_tr, tab_eq, tab_st, tab_wi, tab_pf, tab_cmp = st.tabs([
|
||
"📋 Overview", "📜 Trades", "📈 Equity Chart",
|
||
"📊 Strategies", "🔧 What-If", "🗂 Portfolios", "🔗 Compare",
|
||
])
|
||
|
||
# ═════════════════════════════════════════════════════════════════════════
|
||
# OVERVIEW
|
||
# ═════════════════════════════════════════════════════════════════════════
|
||
with tab_ov:
|
||
if not stats:
|
||
st.warning("No data for selected view.")
|
||
else:
|
||
np_ = stats.get("net_profit", 0)
|
||
nc = "pos" if np_ >= 0 else "neg"
|
||
|
||
def card(label, val, sub, cls="neutral"):
|
||
st.markdown(
|
||
f'<div class="stat-card"><div class="stat-label">{label}</div>'
|
||
f'<div class="stat-value {cls}">{val}</div>'
|
||
f'<div class="stat-sub">{sub}</div></div>',
|
||
unsafe_allow_html=True)
|
||
|
||
c1,c2,c3,c4,c5 = st.columns(5)
|
||
with c1: card("Total Profit", f"${np_:,.2f}",
|
||
f"{stats.get('num_trades',0):,} trades", nc)
|
||
with c2: card("Win Rate", f"{stats.get('win_rate',0):.2f}%",
|
||
f"{stats.get('win_count',0)}W / {stats.get('loss_count',0)}L")
|
||
with c3:
|
||
pf = stats.get("profit_factor", 0)
|
||
card("Profit Factor", f"{pf:.2f}" if pf != float("inf") else "∞",
|
||
"Gross P / Gross L")
|
||
with c4: card("Max Drawdown", f"${stats.get('max_dd',0):,.2f}",
|
||
f"{stats.get('max_dd_pct',0):.2f}%", "neg")
|
||
with c5: card("Return / DD", f"{stats.get('ret_dd_ratio',0):.2f}",
|
||
"Net profit / max DD")
|
||
|
||
st.markdown("<br>", unsafe_allow_html=True)
|
||
r1,r2,r3,r4,r5 = st.columns(5)
|
||
with r1: card("Yearly Avg", f"${stats.get('yearly_avg_profit',0):,.2f}", "Annual")
|
||
with r2: card("Monthly Avg", f"${stats.get('monthly_avg_profit',0):,.2f}", "Per month")
|
||
with r3: card("CAGR", f"{stats.get('cagr',0)*100:.2f}%", "Compound annual")
|
||
with r4:
|
||
at = stats.get("avg_trade",0)
|
||
card("Avg Trade", f"${at:,.2f}", "Per trade", "pos" if at>=0 else "neg")
|
||
with r5: card("Max Stagnation",f"{stats.get('max_stagnation_days',0)}d",
|
||
"Days w/o new high")
|
||
|
||
st.markdown("<br>", unsafe_allow_html=True)
|
||
lc, rc = st.columns(2)
|
||
|
||
def kv(key, val, cls=""):
|
||
st.markdown(
|
||
f'<div class="kv-row"><span class="kk">{key}</span>'
|
||
f'<span class="kv-v {cls}">{val}</span></div>',
|
||
unsafe_allow_html=True)
|
||
|
||
with lc:
|
||
st.markdown('<div class="sh">Strategy</div>', unsafe_allow_html=True)
|
||
kv("# Trades", f"{stats.get('num_trades',0):,}")
|
||
kv("Gross Profit", f"${stats.get('gross_profit',0):,.2f}", "pos")
|
||
kv("Gross Loss", f"${stats.get('gross_loss',0):,.2f}", "neg")
|
||
kv("Avg Win", f"${stats.get('avg_win',0):,.2f}", "pos")
|
||
kv("Avg Loss", f"${stats.get('avg_loss',0):,.2f}", "neg")
|
||
kv("W/L Ratio", f"{stats.get('win_count',0)} / {stats.get('loss_count',0)}")
|
||
with rc:
|
||
st.markdown('<div class="sh">Risk</div>', unsafe_allow_html=True)
|
||
kv("Max Consec Wins", str(stats.get("max_consec_wins",0)), "pos")
|
||
kv("Max Consec Losses", str(stats.get("max_consec_losses",0)), "neg")
|
||
kv("Max DD $", f"${stats.get('max_dd',0):,.2f}", "neg")
|
||
kv("Max DD %", f"{stats.get('max_dd_pct',0):.2f}%", "neg")
|
||
kv("Start Date", str(stats.get("start_date","—"))[:10])
|
||
kv("End Date", str(stats.get("end_date","—"))[:10])
|
||
|
||
# [1] Monthly table toggle $ / %
|
||
if "monthly_table_dollar" in stats:
|
||
st.markdown("<br>", unsafe_allow_html=True)
|
||
mt_col1, mt_col2 = st.columns([3, 1])
|
||
mt_col1.markdown('<div class="sh">Monthly Performance</div>',
|
||
unsafe_allow_html=True)
|
||
mt_mode = mt_col2.radio("Unit", ["$", "%"],
|
||
horizontal=True, key="pb_mt_mode")
|
||
tbl_key = "monthly_table_dollar" if mt_mode == "$" else "monthly_table_pct"
|
||
st.markdown(_monthly_html(stats[tbl_key], mt_mode),
|
||
unsafe_allow_html=True)
|
||
|
||
# ═════════════════════════════════════════════════════════════════════════
|
||
# TRADES
|
||
# ═════════════════════════════════════════════════════════════════════════
|
||
with tab_tr:
|
||
if df.empty:
|
||
st.info("No trades in selected view.")
|
||
else:
|
||
tr_date_from, tr_date_to = _date_slider("pb_tr")
|
||
|
||
fc1, fc2, fc3, fc4, fc5 = st.columns(5)
|
||
all_eas = sorted(df["_ea"].dropna().unique().tolist()) if "_ea" in df.columns else []
|
||
all_syms = sorted(df["symbol"].dropna().unique().tolist()) if "symbol" in df.columns else []
|
||
all_types = sorted(df["type"].dropna().unique().tolist()) if "type" in df.columns else []
|
||
filt_ea = fc1.multiselect("EA", all_eas, default=all_eas, key="pb_tea")
|
||
# Cascade strategies from EA filter
|
||
if filt_ea and "_ea" in df.columns:
|
||
avail_strats = sorted(df[df["_ea"].isin(filt_ea)]["strategy"].dropna().unique().tolist()) \
|
||
if "strategy" in df.columns else []
|
||
else:
|
||
avail_strats = sorted(df["strategy"].dropna().unique().tolist()) \
|
||
if "strategy" in df.columns else []
|
||
filt_strat = fc2.multiselect("Strategy", avail_strats, default=avail_strats, key="pb_tst")
|
||
filt_sym = fc3.multiselect("Symbol", all_syms, default=all_syms, key="pb_ts")
|
||
filt_type = fc4.multiselect("Direction", all_types, default=all_types, key="pb_tt")
|
||
result_f = fc5.selectbox("Result", ["All","Wins only","Losses only"], key="pb_tr")
|
||
|
||
view = df.copy()
|
||
if "close_time" in view.columns and tr_date_from and tr_date_to:
|
||
ct = pd.to_datetime(view["close_time"]).dt.tz_localize(None)
|
||
view = view[
|
||
(ct >= pd.Timestamp(tr_date_from)) &
|
||
(ct <= pd.Timestamp(tr_date_to) + pd.Timedelta(days=1))
|
||
]
|
||
if filt_ea and "_ea" in view.columns: view = view[view["_ea"].isin(filt_ea)]
|
||
if filt_strat and "strategy" in view.columns: view = view[view["strategy"].isin(filt_strat)]
|
||
if filt_sym and "symbol" in view.columns: view = view[view["symbol"].isin(filt_sym)]
|
||
if filt_type and "type" in view.columns: view = view[view["type"].isin(filt_type)]
|
||
if result_f == "Wins only": view = view[view["net_profit"] > 0]
|
||
elif result_f == "Losses only": view = view[view["net_profit"] <= 0]
|
||
|
||
keep = [c for c in ["_strategy","symbol","type","open_time","open_price",
|
||
"close_time","close_price","volume","net_profit","comment"]
|
||
if c in view.columns]
|
||
rename = {"_strategy":"Strategy","symbol":"Symbol","type":"Type",
|
||
"open_time":"Open Time","open_price":"Open Price",
|
||
"close_time":"Close Time","close_price":"Close Price",
|
||
"volume":"Volume","net_profit":"P/L ($)","comment":"Comment"}
|
||
ddf = view[keep].rename(columns=rename).copy()
|
||
for dc in ["Open Time","Close Time"]:
|
||
if dc in ddf.columns:
|
||
ddf[dc] = pd.to_datetime(ddf[dc], errors="coerce").dt.strftime("%d.%m.%Y %H:%M")
|
||
|
||
# [6] Format all numeric columns to 2dp
|
||
num_cols = ddf.select_dtypes(include="number").columns.tolist()
|
||
fmt_dict = {c: "{:.2f}" for c in num_cols}
|
||
|
||
# Compact stats bar above trade list
|
||
tr_stats = _calc_stats(view, deposit)
|
||
if tr_stats:
|
||
st.caption("Stats reflect the filtered trade list below — does not affect Overview, Equity Chart or Strategies tabs.")
|
||
ts1,ts2,ts3,ts4,ts5,ts6 = st.columns(6)
|
||
_np = tr_stats.get("net_profit",0)
|
||
ts1.metric("Trades", f"{tr_stats.get('num_trades',0):,}")
|
||
ts2.metric("Net Profit", f"${_np:,.2f}")
|
||
ts3.metric("Win Rate", f"{tr_stats.get('win_rate',0):.2f}%")
|
||
ts4.metric("Profit Factor", f"{tr_stats.get('profit_factor',0):.2f}"
|
||
if tr_stats.get('profit_factor',0) != float('inf') else "∞")
|
||
ts5.metric("Max DD", f"${tr_stats.get('max_dd',0):,.2f}")
|
||
ts6.metric("Avg Trade", f"${tr_stats.get('avg_trade',0):.2f}")
|
||
st.markdown("")
|
||
|
||
st.caption(f"{len(ddf):,} trades · use ⛶ to expand full screen")
|
||
|
||
def _hl(val):
|
||
if not isinstance(val, (int,float)): return ""
|
||
import os, re as _re
|
||
_cfg = os.path.join(os.path.dirname(os.path.abspath(__file__)), ".streamlit", "config.toml")
|
||
_light = False
|
||
if os.path.isfile(_cfg):
|
||
_m = _re.search(r'base\s*=\s*"([^"]*)"', open(_cfg).read())
|
||
if _m: _light = _m.group(1) == "light"
|
||
if _light:
|
||
if val > 0: return "background-color:rgba(52,194,122,0.15)"
|
||
if val < 0: return "background-color:rgba(220,50,50,0.12)"
|
||
else:
|
||
if val > 0: return "background-color:#1A3A26"
|
||
if val < 0: return "background-color:#3A1A1A"
|
||
return ""
|
||
|
||
# No fixed height — Streamlit will size to content on the page
|
||
# and properly fill the screen when the fullscreen icon is clicked.
|
||
st.dataframe(
|
||
ddf.style
|
||
.format(fmt_dict)
|
||
.map(_hl, subset=["P/L ($)"] if "P/L ($)" in ddf.columns else []),
|
||
use_container_width=True,
|
||
)
|
||
buf = io.StringIO()
|
||
ddf.to_csv(buf, index=False)
|
||
st.download_button("⬇️ Export CSV", buf.getvalue(),
|
||
file_name=f"trades_{active_label}.csv", mime="text/csv")
|
||
|
||
# ═════════════════════════════════════════════════════════════════════════
|
||
# EQUITY CHART
|
||
# ═════════════════════════════════════════════════════════════════════════
|
||
with tab_eq:
|
||
if df.empty or "close_time" not in df.columns:
|
||
st.info("No time-series data available.")
|
||
else:
|
||
# [8] Line mode options
|
||
ctl1, ctl2, ctl3 = st.columns([3, 2, 2])
|
||
chart_view = ctl1.radio(
|
||
"Lines",
|
||
["Portfolio", "By EA", "By Strategy", "EA + Strategy"],
|
||
horizontal=True, key="pb_cv",
|
||
)
|
||
smooth_window = ctl2.slider("Smoothing", 1, 50, 1, key="pb_sm",
|
||
help="Rolling-average window (trades). 1 = raw.")
|
||
show_stag = ctl3.checkbox("Show stagnation band", value=True, key="pb_stag")
|
||
|
||
# Date range slider
|
||
date_from, date_to = _date_slider("pb_eq")
|
||
|
||
# EA filter + cascading strategy filter
|
||
all_eas_eq = sorted(df["_ea"].dropna().unique().tolist()) if "_ea" in df.columns else list(eff_dfs.keys())
|
||
sel_eas_eq = st.multiselect("Filter EA", all_eas_eq, default=all_eas_eq, key="pb_eq_ea")
|
||
|
||
if chart_view in ("By Strategy", "EA + Strategy"):
|
||
if sel_eas_eq and "_ea" in df.columns and "strategy" in df.columns:
|
||
avail_strats_eq = sorted(df[df["_ea"].isin(sel_eas_eq)]["strategy"].dropna().unique().tolist())
|
||
else:
|
||
avail_strats_eq = sorted(df["strategy"].dropna().unique().tolist()) if "strategy" in df.columns else []
|
||
sel_strats_eq = st.multiselect("Filter Strategy", avail_strats_eq, default=avail_strats_eq, key="pb_eq_strat")
|
||
else:
|
||
sel_strats_eq = []
|
||
|
||
# Build per-EA and per-strategy dfs for charting
|
||
# Per-EA: combine all trades for that EA filename
|
||
ea_dfs = {}
|
||
for ea in all_eas_eq:
|
||
if ea not in sel_eas_eq:
|
||
continue
|
||
ea_trades = df[df["_ea"] == ea] if "_ea" in df.columns else pd.DataFrame()
|
||
if not ea_trades.empty:
|
||
ea_trades = ea_trades.sort_values("close_time").reset_index(drop=True)
|
||
ea_dfs[ea] = ea_trades
|
||
|
||
# Per-strategy: combine all trades sharing the same strategy comment
|
||
strat_dfs = {}
|
||
if "strategy" in df.columns:
|
||
for strat in (sel_strats_eq if sel_strats_eq else df["strategy"].dropna().unique()):
|
||
mask = df["strategy"] == strat
|
||
if sel_eas_eq and "_ea" in df.columns:
|
||
mask &= df["_ea"].isin(sel_eas_eq)
|
||
s_trades = df[mask]
|
||
if not s_trades.empty:
|
||
s_trades = s_trades.sort_values("close_time").reset_index(drop=True)
|
||
strat_dfs[strat] = s_trades
|
||
|
||
# Determine what to pass to the chart builder
|
||
if chart_view == "By EA":
|
||
chart_eff_dfs = ea_dfs
|
||
sel_strats = list(ea_dfs.keys())
|
||
chart_cv = "Individual"
|
||
elif chart_view == "By Strategy":
|
||
chart_eff_dfs = strat_dfs
|
||
sel_strats = list(strat_dfs.keys())
|
||
chart_cv = "Individual"
|
||
elif chart_view == "EA + Strategy":
|
||
chart_eff_dfs = {**ea_dfs, **strat_dfs}
|
||
sel_strats = list(ea_dfs.keys()) + list(strat_dfs.keys())
|
||
chart_cv = "Portfolio+Individual"
|
||
else: # Portfolio
|
||
chart_eff_dfs = eff_dfs
|
||
sel_strats = list(eff_dfs.keys())
|
||
chart_cv = "Portfolio"
|
||
|
||
# Combined df for portfolio line
|
||
chart_df = df
|
||
if chart_view == "EA + Strategy" and ea_dfs:
|
||
chart_df = _combine(ea_dfs, deposit)
|
||
|
||
cv_map = {
|
||
"Portfolio": "Portfolio",
|
||
"By EA": "Individual",
|
||
"By Strategy": "Individual",
|
||
"EA + Strategy":"Portfolio+Individual",
|
||
}
|
||
fig = _build_equity_chart(
|
||
chart_df, deposit, chart_eff_dfs, portfolios, active_label,
|
||
chart_view=cv_map[chart_view],
|
||
smooth_window=smooth_window,
|
||
show_stagnation=show_stag,
|
||
date_from=date_from, date_to=date_to,
|
||
selected_strategies=sel_strats,
|
||
)
|
||
st.plotly_chart(fig, use_container_width=True)
|
||
|
||
# ═════════════════════════════════════════════════════════════════════════
|
||
# STRATEGIES TABLE [2] lot size, no CAGR [3] smoothing [4] taller chart
|
||
# ═════════════════════════════════════════════════════════════════════════
|
||
with tab_st:
|
||
st.markdown("##### All Strategies — Performance Summary")
|
||
# Apply same date range as Overview
|
||
eff_dfs_filtered = {}
|
||
for _lbl, _sdf in eff_dfs.items():
|
||
if "close_time" in _sdf.columns and ov_date_from and ov_date_to:
|
||
_ct = pd.to_datetime(_sdf["close_time"]).dt.tz_localize(None)
|
||
eff_dfs_filtered[_lbl] = _sdf[
|
||
(_ct >= pd.Timestamp(ov_date_from)) &
|
||
(_ct <= pd.Timestamp(ov_date_to) + pd.Timedelta(days=1))
|
||
]
|
||
else:
|
||
eff_dfs_filtered[_lbl] = _sdf
|
||
tdf = _strategy_table(eff_dfs_filtered, deposit, lot_overrides)
|
||
if tdf.empty:
|
||
st.info("No strategies loaded.")
|
||
else:
|
||
def _cc(val, low=0):
|
||
if not isinstance(val, (int,float)): return ""
|
||
return "color:#34C27A" if val > low else "color:#E05555" if val < low else ""
|
||
|
||
# [6] 2dp formatting for all numeric columns
|
||
num_cols_t = tdf.select_dtypes(include="number").columns.tolist()
|
||
fmt_t = {c: "{:.2f}" for c in num_cols_t if c != "Trades"}
|
||
fmt_t["Trades"] = "{:.0f}"
|
||
|
||
styled = (
|
||
tdf.style
|
||
.format(fmt_t)
|
||
.map(_cc, subset=["Net Profit ($)","Avg Trade ($)"])
|
||
.map(lambda v: _cc(v, 1.0), subset=["Profit Factor"])
|
||
.map(lambda v: "color:#E05555"
|
||
if isinstance(v,(int,float)) and v < 0 else "",
|
||
subset=["Max DD ($)","Max DD (%)"])
|
||
)
|
||
st.dataframe(styled, use_container_width=True, hide_index=True)
|
||
|
||
# Controls row
|
||
st.markdown("##### Equity Curves")
|
||
ctl1, ctl2, ctl3, ctl4 = st.columns([2, 2, 2, 2])
|
||
sc_smooth = ctl1.slider("Curve smoothing", 1, 50, 1, key="pb_st_smooth",
|
||
help="Rolling-average window (trades).")
|
||
st_curve_grp = ctl2.radio("Group by", ["EA", "Strategy"], horizontal=True, key="pb_st_grp",
|
||
help="EA = one line per file · Strategy = one line per comment")
|
||
show_st_stag = ctl3.toggle("Show stagnation bands", value=False,
|
||
key="pb_st_show_stag",
|
||
help="Highlight max stagnation period per strategy in matching colour")
|
||
|
||
# Build the series to plot
|
||
if st_curve_grp == "Strategy" and "strategy" in df.columns:
|
||
# One series per unique strategy comment across all loaded files
|
||
_st_series = {}
|
||
for _strat in sorted(df["strategy"].dropna().unique()):
|
||
_s_df = df[df["strategy"] == _strat].copy()
|
||
if ov_date_from and ov_date_to and "close_time" in _s_df.columns:
|
||
_ct = pd.to_datetime(_s_df["close_time"]).dt.tz_localize(None)
|
||
_s_df = _s_df[(_ct >= pd.Timestamp(ov_date_from)) &
|
||
(_ct <= pd.Timestamp(ov_date_to) + pd.Timedelta(days=1))]
|
||
if not _s_df.empty:
|
||
_st_series[_strat] = _s_df.sort_values("close_time").reset_index(drop=True)
|
||
else:
|
||
_st_series = eff_dfs_filtered # one series per uploaded file
|
||
|
||
sf = go.Figure()
|
||
sf.update_layout(
|
||
height=500,
|
||
margin=dict(l=40, r=20, t=40, b=10),
|
||
paper_bgcolor="rgba(0,0,0,0)", plot_bgcolor="rgba(0,0,0,0)",
|
||
legend=dict(orientation="h", y=1.08, font=dict(size=10)),
|
||
hovermode="x unified",
|
||
hoverlabel=dict(namelength=-1, font=dict(size=12)),
|
||
)
|
||
sf.update_xaxes(gridcolor="rgba(128,128,128,0.15)", zeroline=False)
|
||
sf.update_yaxes(gridcolor="rgba(128,128,128,0.15)", zeroline=False, tickprefix="$")
|
||
|
||
for i, (lbl, sdf) in enumerate(_st_series.items()):
|
||
if "close_time" not in sdf.columns or "net_profit" not in sdf.columns:
|
||
continue
|
||
color = COLORS[i % len(COLORS)]
|
||
sdf_s = sdf.sort_values("close_time")
|
||
eq = deposit + sdf_s["net_profit"].cumsum()
|
||
eq_s = _smooth(eq.reset_index(drop=True), sc_smooth)
|
||
sf.add_trace(go.Scatter(
|
||
x=sdf_s["close_time"].values, y=eq_s,
|
||
name=lbl, mode="lines",
|
||
line=dict(color=color, width=1.5),
|
||
hovertemplate=f"<b>{lbl}</b><br>%{{x|%d %b %Y}}: $%{{y:,.2f}}<extra></extra>",
|
||
))
|
||
|
||
# Stagnation band per strategy in matching colour
|
||
if show_st_stag:
|
||
eq_ts = sdf_s[["close_time","net_profit"]].dropna().copy()
|
||
eq_ts["cum"] = deposit + eq_ts["net_profit"].cumsum()
|
||
if not eq_ts.empty:
|
||
peak = float(eq_ts["cum"].iloc[0])
|
||
stag_start = eq_ts["close_time"].iloc[0]
|
||
max_days = 0
|
||
best_s = stag_start
|
||
best_e = stag_start
|
||
for _, r in eq_ts.iterrows():
|
||
if float(r["cum"]) > peak:
|
||
days = (r["close_time"] - stag_start).days
|
||
if days > max_days:
|
||
max_days = days
|
||
best_s = stag_start
|
||
best_e = r["close_time"]
|
||
peak = float(r["cum"])
|
||
stag_start = r["close_time"]
|
||
if max_days > 0:
|
||
# Convert hex to rgba with low opacity
|
||
hex_c = color.lstrip("#")
|
||
if len(hex_c) == 6:
|
||
r_c = int(hex_c[0:2], 16)
|
||
g_c = int(hex_c[2:4], 16)
|
||
b_c = int(hex_c[4:6], 16)
|
||
fill_color = f"rgba({r_c},{g_c},{b_c},0.12)"
|
||
ann_color = color
|
||
else:
|
||
fill_color = "rgba(255,160,80,0.12)"
|
||
ann_color = color
|
||
sf.add_vrect(
|
||
x0=best_s, x1=best_e,
|
||
fillcolor=fill_color, line_width=1,
|
||
line_color=f"rgba({r_c},{g_c},{b_c},0.3)" if len(hex_c)==6 else color,
|
||
annotation_text=f"{lbl.split()[0]}… {max_days}d",
|
||
annotation_position="top left",
|
||
annotation_font_size=9,
|
||
annotation_font_color=ann_color,
|
||
)
|
||
|
||
st.plotly_chart(sf, use_container_width=True)
|
||
|
||
# ═════════════════════════════════════════════════════════════════════════
|
||
# WHAT-IF [5] lot-size scaling per strategy
|
||
# ═════════════════════════════════════════════════════════════════════════
|
||
with tab_wi:
|
||
st.markdown("##### What-If: Lot Size Adjustment")
|
||
st.caption(
|
||
"Enter a target lot size for each strategy. The tool calculates the "
|
||
"multiplier automatically from the strategy's average lot size. "
|
||
"Changes apply everywhere (Overview, Equity Chart, Strategies table)."
|
||
)
|
||
|
||
changed = False
|
||
for label in list(strategy_dfs.keys()):
|
||
orig_df = strategy_dfs[label]
|
||
orig_stats = _calc_stats(orig_df, deposit)
|
||
orig_dd = orig_stats.get("max_dd", 0)
|
||
orig_avg_lot = orig_stats.get("avg_lot", 0.0)
|
||
current_mult = lot_overrides.get(label, 1.0)
|
||
|
||
# Derive the currently displayed lot size from the multiplier
|
||
# (avg_lot is from original unscaled data, so effective = orig * mult)
|
||
current_lot = round(orig_avg_lot * current_mult, 4) if orig_avg_lot else current_mult
|
||
|
||
wi_c1, wi_c2, wi_c3, wi_c4 = st.columns([3, 1, 1, 1])
|
||
wi_c1.markdown(f"**{label}**")
|
||
wi_c2.markdown(
|
||
f"<small style='color:#6C7A8D'>Avg lot<br>"
|
||
f"<b style='color:#CDD6F4'>{orig_avg_lot:.4f}</b></small>",
|
||
unsafe_allow_html=True)
|
||
wi_c3.markdown(
|
||
f"<small style='color:#6C7A8D'>Current ×<br>"
|
||
f"<b style='color:#CDD6F4'>{current_mult:.4f}</b></small>",
|
||
unsafe_allow_html=True)
|
||
|
||
new_lot = wi_c4.number_input(
|
||
"Target lot size", min_value=0.0001, max_value=9999.0,
|
||
value=float(current_lot) if current_lot > 0 else float(orig_avg_lot) if orig_avg_lot else 0.01,
|
||
step=0.01, format="%.4f",
|
||
key=f"pb_wi_{label}",
|
||
label_visibility="collapsed",
|
||
help="Enter the lot size you want for this strategy",
|
||
)
|
||
|
||
# Compute new multiplier from target lot / original avg lot
|
||
if orig_avg_lot and orig_avg_lot > 0:
|
||
new_mult = new_lot / orig_avg_lot
|
||
else:
|
||
new_mult = new_lot # fallback: treat as direct multiplier
|
||
|
||
new_mult = round(new_mult, 6)
|
||
if abs(new_mult - current_mult) > 1e-9:
|
||
st.session_state.pb_lot_overrides[label] = new_mult
|
||
changed = True
|
||
|
||
# Before / after metrics
|
||
scaled_df = _scale_df(orig_df, new_mult)
|
||
scaled_stats = _calc_stats(scaled_df, deposit)
|
||
s1, s2, s3, s4 = st.columns(4)
|
||
s1.metric("Net Profit", f"${scaled_stats.get('net_profit',0):,.2f}",
|
||
delta=f"{scaled_stats.get('net_profit',0)-orig_stats.get('net_profit',0):+.2f}")
|
||
s2.metric("Max DD", f"${scaled_stats.get('max_dd',0):,.2f}",
|
||
delta=f"{scaled_stats.get('max_dd',0)-orig_dd:+.2f}")
|
||
s3.metric("Profit Factor", f"{scaled_stats.get('profit_factor',0):.2f}")
|
||
s4.metric("Win Rate", f"{scaled_stats.get('win_rate',0):.2f}%")
|
||
st.markdown("---")
|
||
|
||
if changed:
|
||
st.rerun()
|
||
|
||
if any(v != 1.0 for v in lot_overrides.values()):
|
||
if st.button("Reset all lot sizes to original", key="pb_wi_reset"):
|
||
st.session_state.pb_lot_overrides = {}
|
||
st.rerun()
|
||
|
||
# ═════════════════════════════════════════════════════════════════════════
|
||
# PORTFOLIOS MANAGER
|
||
# ═════════════════════════════════════════════════════════════════════════
|
||
with tab_pf:
|
||
st.markdown("##### Custom Portfolios")
|
||
st.caption("Named portfolios appear in the View dropdown. "
|
||
"Lot-size overrides from the What-If tab are reflected in portfolio stats.")
|
||
|
||
with st.expander("➕ Create new portfolio",
|
||
expanded=not bool(portfolios)):
|
||
pname = st.text_input("Portfolio name", key="pb_pname",
|
||
placeholder="e.g. Gold Strategies")
|
||
members = st.multiselect("Strategies to include",
|
||
list(strategy_dfs.keys()), key="pb_pmembers")
|
||
if st.button("Save portfolio", key="pb_psave"):
|
||
if not pname.strip():
|
||
st.warning("Enter a portfolio name.")
|
||
elif not members:
|
||
st.warning("Select at least one strategy.")
|
||
else:
|
||
st.session_state.pb_portfolios[pname.strip()] = list(members)
|
||
st.success(f"✅ **{pname.strip()}** saved.")
|
||
st.rerun()
|
||
|
||
if not portfolios:
|
||
st.info("No custom portfolios yet.")
|
||
else:
|
||
for pname, members in list(portfolios.items()):
|
||
with st.expander(f"📁 {pname} ({len(members)} strategies)"):
|
||
for m in members:
|
||
mult = lot_overrides.get(m, 1.0)
|
||
tag = "✅" if m in strategy_dfs else "⚠️ not loaded"
|
||
mult_str = f" ×{mult:.2f}" if mult != 1.0 else ""
|
||
st.markdown(f"- {m} {tag}{mult_str}")
|
||
|
||
new_members = st.multiselect(
|
||
"Edit members", list(strategy_dfs.keys()),
|
||
default=[m for m in members if m in strategy_dfs],
|
||
key=f"pb_edit_{pname}",
|
||
)
|
||
ec1, ec2 = st.columns(2)
|
||
if ec1.button("Update", key=f"pb_upd_{pname}"):
|
||
st.session_state.pb_portfolios[pname] = list(new_members)
|
||
st.success("Updated.")
|
||
st.rerun()
|
||
if ec2.button("🗑 Delete", key=f"pb_del_{pname}"):
|
||
del st.session_state.pb_portfolios[pname]
|
||
st.rerun()
|
||
|
||
pm_dfs = {k: eff_dfs[k] for k in members if k in eff_dfs}
|
||
if pm_dfs:
|
||
pdf = _combine(pm_dfs, deposit)
|
||
pstat = _calc_stats(pdf, deposit)
|
||
mc1,mc2,mc3,mc4 = st.columns(4)
|
||
mc1.metric("Net Profit", f"${pstat.get('net_profit',0):,.2f}")
|
||
mc2.metric("Win Rate", f"{pstat.get('win_rate',0):.2f}%")
|
||
mc3.metric("Profit Factor", f"{pstat.get('profit_factor',0):.2f}")
|
||
mc4.metric("Max DD", f"${pstat.get('max_dd',0):,.2f}")
|
||
|
||
# ═════════════════════════════════════════════════════════════════════════
|
||
# COMPARE — correlation between custom portfolios
|
||
# ═════════════════════════════════════════════════════════════════════════
|
||
with tab_cmp:
|
||
st.markdown("##### Portfolio Correlation Comparison")
|
||
st.caption(
|
||
"Compare how the constructed portfolios move relative to each other. "
|
||
"Choose a bucketing mode — daily P&L correlation tells you if portfolios "
|
||
"are diversified day-to-day; hourly close/open windows reveal whether they "
|
||
"tend to enter or exit positions together."
|
||
)
|
||
|
||
# Build the list of comparable portfolios — custom ones plus the 'all' aggregate
|
||
all_options = []
|
||
if eff_dfs:
|
||
all_options.append("Portfolio (all)")
|
||
all_options.extend(list(portfolios.keys()))
|
||
|
||
if len(all_options) < 2:
|
||
st.info("Create at least 2 custom portfolios in the **Portfolios** tab "
|
||
"to enable comparison. (Or load strategies + create one portfolio — "
|
||
"you can then compare it against the full aggregate.)")
|
||
else:
|
||
cmp_c1, cmp_c2, cmp_c3 = st.columns([3, 2, 2])
|
||
with cmp_c1:
|
||
selected_pfs = st.multiselect(
|
||
"Portfolios to compare",
|
||
all_options,
|
||
default=all_options[:min(4, len(all_options))],
|
||
key="pb_cmp_pfs",
|
||
)
|
||
with cmp_c2:
|
||
bucket_mode = st.selectbox(
|
||
"Correlation bucket",
|
||
[
|
||
("daily", "Daily P&L"),
|
||
("close_hour", "Close within 1hr"),
|
||
("open_hour", "Open within 1hr"),
|
||
("weekly", "Weekly P&L"),
|
||
("monthly", "Monthly P&L"),
|
||
],
|
||
format_func=lambda x: x[1],
|
||
key="pb_cmp_bucket",
|
||
)
|
||
bucket_mode = bucket_mode[0]
|
||
with cmp_c3:
|
||
corr_method = st.selectbox(
|
||
"Method",
|
||
["pearson", "spearman", "kendall"],
|
||
key="pb_cmp_method",
|
||
help="Pearson = linear, Spearman = rank-based (robust to outliers), "
|
||
"Kendall = ordinal concordance",
|
||
)
|
||
|
||
if len(selected_pfs) < 2:
|
||
st.warning("Select at least 2 portfolios to compute correlation.")
|
||
else:
|
||
# Build bucketed P&L series for each selected portfolio
|
||
series_dict = {}
|
||
empty_pfs = []
|
||
for pf in selected_pfs:
|
||
s = _portfolio_pnl_series(pf, portfolios, eff_dfs, bucket_mode)
|
||
if s.empty:
|
||
empty_pfs.append(pf)
|
||
else:
|
||
series_dict[pf] = s
|
||
|
||
if empty_pfs:
|
||
st.warning(
|
||
f"No data for: {', '.join(empty_pfs)} (no trades or missing time column)."
|
||
)
|
||
|
||
if len(series_dict) < 2:
|
||
st.error("Need at least 2 non-empty portfolios for correlation.")
|
||
else:
|
||
corr = _correlation_matrix(series_dict, method=corr_method)
|
||
|
||
# ── Correlation matrix heatmap ────────────────────────
|
||
st.markdown("**Correlation Matrix**")
|
||
|
||
# Custom diverging colorscale: red (high corr = bad for diversification)
|
||
# through neutral grey at 0, to green (negative corr = great diversifier)
|
||
fig_corr = go.Figure(data=go.Heatmap(
|
||
z=corr.values,
|
||
x=list(corr.columns),
|
||
y=list(corr.index),
|
||
colorscale=[
|
||
[0.0, "#2E7D32"], # -1 dark green (great diversifier)
|
||
[0.25, "#7ED321"], # -0.5 green
|
||
[0.5, "#3A4255"], # 0 neutral grey-blue
|
||
[0.75, "#F5A623"], # 0.5 amber
|
||
[1.0, "#E63946"], # 1 red (highly correlated)
|
||
],
|
||
zmin=-1, zmax=1,
|
||
text=[[f"{v:.2f}" for v in row] for row in corr.values],
|
||
texttemplate="%{text}",
|
||
textfont={"size": 13, "color": "white"},
|
||
hovertemplate="<b>%{y}</b> vs <b>%{x}</b><br>r = %{z:.3f}<extra></extra>",
|
||
colorbar=dict(title="r", thickness=15),
|
||
))
|
||
fig_corr.update_layout(
|
||
height=max(320, 80 + 50 * len(corr)),
|
||
margin=dict(l=10, r=10, t=10, b=10),
|
||
paper_bgcolor="rgba(0,0,0,0)",
|
||
plot_bgcolor="rgba(0,0,0,0)",
|
||
font=dict(color="#CDD6F4"),
|
||
xaxis=dict(side="bottom", tickangle=-25),
|
||
yaxis=dict(autorange="reversed"),
|
||
)
|
||
st.plotly_chart(fig_corr, use_container_width=True)
|
||
|
||
# ── Pair summary table ────────────────────────────────
|
||
st.markdown("**Pair-wise summary**")
|
||
pairs = []
|
||
cols = list(corr.columns)
|
||
for i in range(len(cols)):
|
||
for j in range(i + 1, len(cols)):
|
||
r = corr.iloc[i, j]
|
||
if r >= 0.7: rating = "🔴 Strongly correlated"
|
||
elif r >= 0.3: rating = "🟠 Moderately correlated"
|
||
elif r >= -0.3: rating = "⚪ Weakly / uncorrelated"
|
||
elif r >= -0.7: rating = "🟢 Moderate diversifier"
|
||
else: rating = "🟢🟢 Strong diversifier"
|
||
# Count overlapping buckets for context
|
||
sa, sb = series_dict[cols[i]], series_dict[cols[j]]
|
||
overlap = len(sa.index.intersection(sb.index))
|
||
pairs.append({
|
||
"Portfolio A": cols[i],
|
||
"Portfolio B": cols[j],
|
||
"Correlation": round(float(r), 3),
|
||
"Overlap buckets": overlap,
|
||
"Assessment": rating,
|
||
})
|
||
pair_df = pd.DataFrame(pairs).sort_values(
|
||
"Correlation", ascending=False, key=lambda s: s.abs()
|
||
)
|
||
st.dataframe(pair_df, use_container_width=True, hide_index=True)
|
||
|
||
# ── Combined equity overlay ───────────────────────────
|
||
st.markdown("**Equity Curves Overlay**")
|
||
eq_fig = go.Figure()
|
||
for idx, pf in enumerate(series_dict.keys()):
|
||
s = series_dict[pf].sort_index()
|
||
equity = deposit + s.cumsum()
|
||
eq_fig.add_trace(go.Scatter(
|
||
x=equity.index, y=equity.values, name=pf,
|
||
mode="lines",
|
||
line=dict(color=COLORS[idx % len(COLORS)], width=2),
|
||
hovertemplate=f"<b>{pf}</b><br>%{{x|%d %b %Y}}<br>"
|
||
f"$%{{y:,.2f}}<extra></extra>",
|
||
))
|
||
eq_fig.update_layout(
|
||
height=420,
|
||
margin=dict(l=10, r=10, t=10, b=10),
|
||
paper_bgcolor="rgba(0,0,0,0)",
|
||
plot_bgcolor="rgba(0,0,0,0)",
|
||
font=dict(color="#CDD6F4"),
|
||
xaxis=dict(gridcolor="rgba(255,255,255,0.05)"),
|
||
yaxis=dict(gridcolor="rgba(255,255,255,0.05)",
|
||
title="Equity ($)"),
|
||
legend=dict(orientation="h", y=1.08, x=0),
|
||
hovermode="x unified",
|
||
)
|
||
st.plotly_chart(eq_fig, use_container_width=True)
|
||
|
||
# ── Rolling correlation between top pair ──────────────
|
||
if len(series_dict) >= 2:
|
||
with st.expander("📈 Rolling correlation (top pair)"):
|
||
# Pick the highest |r| pair for the rolling chart
|
||
top = max(pairs, key=lambda p: abs(p["Correlation"]))
|
||
a, b = top["Portfolio A"], top["Portfolio B"]
|
||
sa = series_dict[a]
|
||
sb = series_dict[b]
|
||
aligned = pd.concat({a: sa, b: sb}, axis=1).fillna(0)
|
||
|
||
# Window depends on bucket mode
|
||
window_default = {
|
||
"daily": 30, "close_hour": 168, "open_hour": 168,
|
||
"weekly": 8, "monthly": 6,
|
||
}.get(bucket_mode, 30)
|
||
window = st.slider(
|
||
"Rolling window (buckets)",
|
||
min_value=5,
|
||
max_value=max(20, min(252, len(aligned))),
|
||
value=min(window_default, max(5, len(aligned) // 4)),
|
||
key="pb_cmp_roll_win",
|
||
)
|
||
if len(aligned) > window:
|
||
roll = aligned[a].rolling(window).corr(aligned[b])
|
||
rfig = go.Figure()
|
||
rfig.add_trace(go.Scatter(
|
||
x=roll.index, y=roll.values,
|
||
mode="lines",
|
||
line=dict(color="#4C8EF5", width=2),
|
||
name=f"{a} vs {b}",
|
||
))
|
||
rfig.add_hline(y=0, line_dash="dash",
|
||
line_color="rgba(255,255,255,0.3)")
|
||
rfig.add_hline(y=0.7, line_dash="dot",
|
||
line_color="rgba(230,57,70,0.4)")
|
||
rfig.add_hline(y=-0.7, line_dash="dot",
|
||
line_color="rgba(46,125,50,0.4)")
|
||
rfig.update_layout(
|
||
height=320,
|
||
margin=dict(l=10, r=10, t=30, b=10),
|
||
paper_bgcolor="rgba(0,0,0,0)",
|
||
plot_bgcolor="rgba(0,0,0,0)",
|
||
font=dict(color="#CDD6F4"),
|
||
title=f"{a} vs {b} — rolling {window}-bucket correlation",
|
||
yaxis=dict(range=[-1, 1],
|
||
gridcolor="rgba(255,255,255,0.05)"),
|
||
xaxis=dict(gridcolor="rgba(255,255,255,0.05)"),
|
||
)
|
||
st.plotly_chart(rfig, use_container_width=True)
|
||
else:
|
||
st.info(f"Need at least {window+1} buckets for rolling "
|
||
f"correlation — only {len(aligned)} available.") |