unknown
1161 lines
66 KiB
Python
1161 lines
66 KiB
Python
"""
|
||
view_portfolio_master.py — Portfolio Master
|
||
Automated portfolio construction with:
|
||
- Composite weighted scoring (Ret/DD, Stability, Stagnation, Win Rate, Growth Quality)
|
||
- Three search modes: Exhaustive | Greedy | Monte Carlo
|
||
- Combination count estimate + runtime warning before run
|
||
- Diversity bonus for multi-symbol / multi-session portfolios
|
||
- Average portfolio correlation output metric
|
||
- Conditional correlation (drawdown periods only)
|
||
- Equity curve growth quality = slope × stability
|
||
- Per-result correlation heatmap in detail expander
|
||
"""
|
||
|
||
import streamlit as st
|
||
import pandas as pd
|
||
import numpy as np
|
||
import plotly.graph_objects as go
|
||
from scipy import stats as scipy_stats
|
||
import io, importlib, sys, os, itertools, random, time
|
||
from datetime import timedelta
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# Parser
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
def _get_parser():
|
||
if "mt5_parser" in sys.modules:
|
||
return importlib.reload(sys.modules["mt5_parser"])
|
||
import mt5_parser
|
||
return mt5_parser
|
||
|
||
|
||
def _parse_file(file_obj):
|
||
try:
|
||
parser = _get_parser()
|
||
raw = file_obj.read()
|
||
result = parser.detect_and_parse(raw)
|
||
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 _normalise(df: pd.DataFrame, label: str) -> pd.DataFrame:
|
||
df = df.copy() # ensure we never mutate the original
|
||
col_map = {}
|
||
def _f(targets, dest):
|
||
for c in targets:
|
||
if c in df.columns and dest not in col_map.values():
|
||
col_map[c] = dest; return
|
||
_f(["open_time","Open time","Open time ($)","Time"], "open_time")
|
||
_f(["close_time","Close time"], "close_time")
|
||
_f(["symbol","Symbol"], "symbol")
|
||
_f(["type","Type","Direction"], "type")
|
||
_f(["net_profit","P/L in money","Profit","profit"], "net_profit")
|
||
_f(["volume","Volume","Size","size"], "volume")
|
||
_f(["commission","Commission"], "commission")
|
||
_f(["swap","Swap"], "swap")
|
||
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["_strategy"] = label
|
||
return df
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# Full per-strategy statistics
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
def _full_stats(df: pd.DataFrame, deposit: float, idx: int, custom_name: str) -> dict:
|
||
s = {}
|
||
if df.empty or "net_profit" not in df.columns:
|
||
return s
|
||
|
||
label = df["_strategy"].iloc[0] if "_strategy" in df.columns else f"#{idx}"
|
||
symbol = df["symbol"].iloc[0] if "symbol" in df.columns else ""
|
||
profits = df["net_profit"].fillna(0)
|
||
|
||
s["#"] = idx
|
||
s["Strategy Name"] = custom_name if custom_name else label
|
||
s["Symbol"] = str(symbol).split(".")[0] if symbol else ""
|
||
s["# Trades"] = len(df)
|
||
s["Net Profit ($)"] = round(float(profits.sum()), 2)
|
||
s["Avg Win ($)"] = round(float(profits[profits > 0].mean()), 2) if (profits > 0).any() else 0.0
|
||
s["Avg Loss ($)"] = round(float(profits[profits < 0].mean()), 2) if (profits < 0).any() else 0.0
|
||
s["% Wins"] = round(float((profits > 0).sum() / len(profits) * 100), 2)
|
||
|
||
gp = float(profits[profits > 0].sum())
|
||
gl = float(profits[profits < 0].sum())
|
||
s["Profit Factor"] = round(gp / abs(gl), 2) if gl else 999.0
|
||
|
||
if "commission" in df.columns:
|
||
s["Commissions ($)"] = round(float(pd.to_numeric(df["commission"], errors="coerce").fillna(0).sum()), 2)
|
||
else:
|
||
s["Commissions ($)"] = 0.0
|
||
|
||
eq = deposit + profits.cumsum()
|
||
rm = eq.cummax()
|
||
dd = eq - rm
|
||
s["Max DD ($)"] = round(float(dd.min()), 2)
|
||
s["Max DD (%)"] = round(float(dd.min() / deposit * 100), 2)
|
||
s["Ret/DD"] = round(s["Net Profit ($)"] / abs(s["Max DD ($)"]), 2) if s["Max DD ($)"] else 0.0
|
||
|
||
if "close_time" in df.columns and "open_time" in df.columns:
|
||
vc = df["close_time"].dropna(); vo = df["open_time"].dropna()
|
||
if not vc.empty:
|
||
start = vo.min() if not vo.empty else vc.min()
|
||
end = vc.max()
|
||
days = max((end - start).days, 1)
|
||
yrs = days / 365.25
|
||
s["Annual Profit ($)"] = round(s["Net Profit ($)"] / yrs, 2)
|
||
s["Annual Profit (%)"] = round(s["Net Profit ($)"] / deposit / yrs * 100, 2)
|
||
else:
|
||
s["Annual Profit ($)"] = s["Annual Profit (%)"] = 0.0
|
||
else:
|
||
s["Annual Profit ($)"] = s["Annual Profit (%)"] = 0.0
|
||
|
||
|
||
|
||
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()
|
||
total_days = max((dly["date"].iloc[-1] - dly["date"].iloc[0]).days, 1)
|
||
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["Stagnation (days)"] = max_stag
|
||
s["Stagnation (%)"] = round(max_stag / total_days * 100, 2)
|
||
else:
|
||
s["Stagnation (days)"] = 0; s["Stagnation (%)"] = 0.0
|
||
else:
|
||
s["Stagnation (days)"] = 0; s["Stagnation (%)"] = 0.0
|
||
|
||
# Stability (R²) and Growth Quality (slope × R²)
|
||
if len(eq) > 2:
|
||
x = np.arange(len(eq))
|
||
slope, intercept, r, p, se = scipy_stats.linregress(x, eq.values)
|
||
r2 = float(r ** 2)
|
||
s["Stability"] = int(round(r2 * 100)) # 0-100
|
||
# Normalise slope to per-trade return as % of deposit, then multiply by R²
|
||
norm_slope = float(slope) / deposit * 100
|
||
s["Growth Quality"] = int(round(norm_slope * r2 * 10000)) # whole number
|
||
else:
|
||
s["Stability"] = 0; s["Growth Quality"] = 0
|
||
|
||
return s
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# Daily P&L and correlation helpers
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
def _daily_pnl(df: pd.DataFrame) -> pd.Series:
|
||
if df.empty or "close_time" not in df.columns or "net_profit" not in df.columns:
|
||
return pd.Series(dtype=float)
|
||
tmp = df[["close_time","net_profit"]].dropna().copy()
|
||
tmp["date"] = pd.to_datetime(tmp["close_time"]).dt.tz_localize(None).dt.normalize()
|
||
return tmp.groupby("date")["net_profit"].sum()
|
||
|
||
|
||
def _correlation_matrix(dfs: dict) -> pd.DataFrame:
|
||
series = {lbl: _daily_pnl(df) for lbl, df in dfs.items()}
|
||
aligned = pd.DataFrame(series).fillna(0)
|
||
return aligned.corr()
|
||
|
||
|
||
def _conditional_correlation(dfs: dict, deposit: float) -> pd.DataFrame:
|
||
"""Correlation computed only on days where the combined portfolio is in drawdown."""
|
||
series = {lbl: _daily_pnl(df) for lbl, df in dfs.items()}
|
||
aligned = pd.DataFrame(series).fillna(0)
|
||
combined_daily = aligned.sum(axis=1)
|
||
cum = deposit + combined_daily.cumsum()
|
||
in_dd = cum < cum.cummax()
|
||
dd_days = aligned[in_dd]
|
||
if len(dd_days) < 5:
|
||
return aligned.corr() # fallback if not enough drawdown days
|
||
return dd_days.corr()
|
||
|
||
|
||
def _portfolio_exceeds_corr(members: list, corr_matrix: pd.DataFrame, max_corr: float) -> bool:
|
||
for a, b in itertools.combinations(members, 2):
|
||
if a in corr_matrix.index and b in corr_matrix.columns:
|
||
if abs(corr_matrix.loc[a, b]) > max_corr:
|
||
return True
|
||
return False
|
||
|
||
|
||
def _avg_correlation(members: list, corr_matrix: pd.DataFrame) -> float:
|
||
"""Average pairwise correlation across all member pairs."""
|
||
pairs = list(itertools.combinations(members, 2))
|
||
if not pairs:
|
||
return 0.0
|
||
vals = []
|
||
for a, b in pairs:
|
||
if a in corr_matrix.index and b in corr_matrix.columns:
|
||
vals.append(abs(corr_matrix.loc[a, b]))
|
||
return round(float(np.mean(vals)), 4) if vals else 0.0
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# Diversity bonus
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
def _diversity_bonus(members: list, dfs: dict) -> float:
|
||
"""
|
||
Returns a bonus score 0.0–1.0 based on:
|
||
- Symbol diversity (unique symbols / n_members)
|
||
- Session diversity (strategies trading at different hours)
|
||
"""
|
||
if len(members) < 2:
|
||
return 0.0
|
||
|
||
symbols = []
|
||
hour_sets = []
|
||
for m in members:
|
||
df = dfs.get(m)
|
||
if df is None: continue
|
||
# Symbol
|
||
if "symbol" in df.columns:
|
||
sym = str(df["symbol"].iloc[0]).split(".")[0].upper()
|
||
symbols.append(sym)
|
||
# Trading hours — get modal hour of closes
|
||
if "close_time" in df.columns:
|
||
hrs = pd.to_datetime(df["close_time"], errors="coerce").dt.hour.dropna()
|
||
if not hrs.empty:
|
||
hour_sets.append(set(hrs.value_counts().head(6).index.tolist()))
|
||
|
||
sym_score = len(set(symbols)) / len(members) if symbols else 0.0
|
||
|
||
session_score = 0.0
|
||
if len(hour_sets) >= 2:
|
||
overlaps = []
|
||
for h1, h2 in itertools.combinations(hour_sets, 2):
|
||
if h1 | h2:
|
||
overlaps.append(len(h1 & h2) / len(h1 | h2))
|
||
session_score = 1.0 - (sum(overlaps) / len(overlaps)) if overlaps else 0.0
|
||
|
||
return int(round((sym_score * 0.6 + session_score * 0.4) * 100)) # 0-100
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# Composite scoring
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
def _composite_score(full: dict, weights: dict, diversity: float, deposit: float) -> float:
|
||
"""
|
||
Weighted composite score. Each metric is normalised before weighting.
|
||
weights keys: ret_dd, stability, stagnation, win_rate, growth_quality, diversity
|
||
"""
|
||
def _norm(val, low, high):
|
||
if high == low: return 0.5
|
||
return max(0.0, min(1.0, (val - low) / (high - low)))
|
||
|
||
ret_dd = full.get("Ret/DD", 0.0)
|
||
stab = full.get("Stability", 0.0)
|
||
stag = full.get("Stagnation (%)", 100.0)
|
||
wr = full.get("% Wins", 0.0)
|
||
gq = full.get("Growth Quality", 0.0)
|
||
|
||
# Normalise each component (rough reasonable ranges)
|
||
n_ret_dd = _norm(ret_dd, 0, 10)
|
||
n_stab = _norm(stab, 0, 1)
|
||
n_stag = _norm(100-stag, 0, 100) # inverted: lower stagnation = higher score
|
||
n_wr = _norm(wr, 40, 90)
|
||
n_gq = _norm(gq, 0, 0.05)
|
||
n_div = _norm(diversity, 0, 1)
|
||
|
||
score = (
|
||
weights.get("ret_dd", 0.35) * n_ret_dd +
|
||
weights.get("stability", 0.25) * n_stab +
|
||
weights.get("stagnation", 0.20) * n_stag +
|
||
weights.get("win_rate", 0.10) * n_wr +
|
||
weights.get("growth_quality",0.05)* n_gq +
|
||
weights.get("diversity", 0.05) * n_div
|
||
)
|
||
return int(round(float(score) * 1000))
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# Portfolio evaluation (single combo)
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
def _evaluate_combo(members: list, dfs: dict, deposit: float,
|
||
weights: dict, corr_matrix: pd.DataFrame,
|
||
cond_corr_matrix: pd.DataFrame) -> dict:
|
||
frames = [dfs[m].copy() for m in members if m in dfs]
|
||
if not frames: return {}
|
||
combined = pd.concat(frames, ignore_index=True)
|
||
if "close_time" in combined.columns:
|
||
combined = combined.sort_values("close_time").reset_index(drop=True)
|
||
combined["_strategy"] = " + ".join(members)
|
||
|
||
full = _full_stats(combined, deposit, 0, " + ".join(members))
|
||
diversity = _diversity_bonus(members, dfs)
|
||
score = _composite_score(full, weights, diversity, deposit)
|
||
avg_corr = _avg_correlation(members, corr_matrix)
|
||
avg_cond = _avg_correlation(members, cond_corr_matrix)
|
||
|
||
return {
|
||
"members": members,
|
||
"score": score,
|
||
"net_profit": full.get("Net Profit ($)", 0.0),
|
||
"max_dd": full.get("Max DD ($)", 0.0),
|
||
"ret_dd": full.get("Ret/DD", 0.0),
|
||
"stag_pct": full.get("Stagnation (%)", 0.0),
|
||
"stability": full.get("Stability", 0.0),
|
||
"growth_quality":full.get("Growth Quality", 0.0),
|
||
"diversity": diversity,
|
||
"avg_corr": avg_corr,
|
||
"avg_cond_corr": avg_cond,
|
||
"full_stats": full,
|
||
}
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# Search modes
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
def _search_exhaustive(labels, dfs, deposit, weights, min_s, max_s,
|
||
use_corr, corr_limit, corr_matrix, cond_corr_matrix,
|
||
max_results, prog_cb, cancelled=None):
|
||
results = []
|
||
total = sum(
|
||
sum(1 for _ in itertools.combinations(labels, r))
|
||
for r in range(min_s, max_s + 1)
|
||
)
|
||
done = 0
|
||
for size in range(min_s, max_s + 1):
|
||
for combo in itertools.combinations(labels, size):
|
||
combo = list(combo)
|
||
done += 1
|
||
if done % 100 == 0:
|
||
prog_cb(done, total, f"Exhaustive: {done:,} / {total:,}")
|
||
if use_corr and corr_matrix is not None:
|
||
if _portfolio_exceeds_corr(combo, corr_matrix, corr_limit):
|
||
continue
|
||
if cancelled and cancelled(): break
|
||
r = _evaluate_combo(combo, dfs, deposit, weights, corr_matrix, cond_corr_matrix)
|
||
if r: results.append(r)
|
||
if cancelled and cancelled(): break
|
||
prog_cb(total, total, "Cancelled." if (cancelled and cancelled()) else "Done.")
|
||
results.sort(key=lambda x: x["score"], reverse=True)
|
||
return results[:max_results]
|
||
|
||
|
||
def _search_greedy(labels, dfs, deposit, weights, min_s, max_s,
|
||
use_corr, corr_limit, corr_matrix, cond_corr_matrix,
|
||
max_results, prog_cb, cancelled=None):
|
||
"""
|
||
Greedy incremental build: start with best single strategy,
|
||
repeatedly add the strategy that most improves the composite score.
|
||
Runs once per starting strategy to explore diverse starting points.
|
||
"""
|
||
results = []
|
||
n = len(labels)
|
||
total_starts = n
|
||
for start_idx, seed in enumerate(labels):
|
||
prog_cb(start_idx, total_starts, f"Greedy: seed {start_idx+1}/{total_starts}")
|
||
current = [seed]
|
||
# Grow until max_s
|
||
while len(current) < max_s:
|
||
best_score = -999
|
||
best_add = None
|
||
for candidate in labels:
|
||
if candidate in current: continue
|
||
trial = current + [candidate]
|
||
if use_corr and corr_matrix is not None:
|
||
if _portfolio_exceeds_corr(trial, corr_matrix, corr_limit):
|
||
continue
|
||
r = _evaluate_combo(trial, dfs, deposit, weights, corr_matrix, cond_corr_matrix)
|
||
if r and r["score"] > best_score:
|
||
best_score = r["score"]
|
||
best_add = candidate
|
||
if best_add is None: break
|
||
current.append(best_add)
|
||
# Record each size if >= min_s
|
||
if len(current) >= min_s:
|
||
r = _evaluate_combo(current[:], dfs, deposit, weights, corr_matrix, cond_corr_matrix)
|
||
if r: results.append(r)
|
||
|
||
if cancelled and cancelled(): break
|
||
prog_cb(total_starts, total_starts, "Cancelled." if (cancelled and cancelled()) else "Done.")
|
||
# Deduplicate by member set
|
||
seen = set(); unique = []
|
||
for r in sorted(results, key=lambda x: x["score"], reverse=True):
|
||
key = frozenset(r["members"])
|
||
if key not in seen:
|
||
seen.add(key); unique.append(r)
|
||
return unique[:max_results]
|
||
|
||
|
||
def _search_montecarlo(labels, dfs, deposit, weights, min_s, max_s,
|
||
use_corr, corr_limit, corr_matrix, cond_corr_matrix,
|
||
max_results, n_samples, prog_cb, cancelled=None):
|
||
results = []; seen = set()
|
||
for i in range(n_samples):
|
||
if i % 100 == 0:
|
||
prog_cb(i, n_samples, f"Monte Carlo: {i:,} / {n_samples:,} samples")
|
||
size = random.randint(min_s, min(max_s, len(labels)))
|
||
combo = sorted(random.sample(labels, size))
|
||
key = frozenset(combo)
|
||
if key in seen: continue
|
||
seen.add(key)
|
||
if use_corr and corr_matrix is not None:
|
||
if _portfolio_exceeds_corr(combo, corr_matrix, corr_limit):
|
||
continue
|
||
r = _evaluate_combo(combo, dfs, deposit, weights, corr_matrix, cond_corr_matrix)
|
||
if r: results.append(r)
|
||
if cancelled and cancelled(): break
|
||
prog_cb(n_samples, n_samples, "Cancelled." if (cancelled and cancelled()) else "Done.")
|
||
results.sort(key=lambda x: x["score"], reverse=True)
|
||
return results[:max_results]
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# Combination count estimate
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
def _combo_estimate(n: int, min_s: int, max_s: int) -> int:
|
||
from math import comb
|
||
return sum(comb(n, r) for r in range(min_s, max_s + 1))
|
||
|
||
|
||
def _time_estimate(n_combos: int) -> str:
|
||
# Rough: ~0.5ms per combo for small DFs, slower for large ones
|
||
secs = n_combos * 0.0008
|
||
if secs < 60: return f"~{secs:.0f}s"
|
||
if secs < 3600: return f"~{secs/60:.0f} min"
|
||
return f"~{secs/3600:.1f} hrs"
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# Correlation heatmap figure (reused in strategies tab and result expanders)
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
def _corr_fig(corr: pd.DataFrame, title: str = "", height: int = 300) -> go.Figure:
|
||
labels = list(corr.columns)
|
||
fig = go.Figure(go.Heatmap(
|
||
z=corr.values, x=labels, y=labels,
|
||
colorscale=[
|
||
[0.00,"#2166AC"],[0.25,"#92C5DE"],[0.50,"#E8E8E8"],
|
||
[0.75,"#F4A582"],[1.00,"#B2182B"],
|
||
],
|
||
zmid=0, zmin=-1, zmax=1,
|
||
text=np.round(corr.values, 2),
|
||
texttemplate="%{text}",
|
||
textfont=dict(size=10, color="#1a1a2e"),
|
||
hovertemplate="%{x} / %{y}: %{z:.3f}<extra></extra>",
|
||
))
|
||
fig.update_layout(
|
||
title=dict(text=title, font=dict(size=11, color="#6C7A8D")) if title else {},
|
||
height=height,
|
||
margin=dict(l=20, r=60, t=30 if title else 10, b=10),
|
||
paper_bgcolor="#F0F2F6", plot_bgcolor="#F0F2F6",
|
||
xaxis=dict(tickfont=dict(size=9, color="#333"), tickangle=-30),
|
||
yaxis=dict(tickfont=dict(size=9, color="#333")),
|
||
)
|
||
return fig
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# Session state
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
def _init_state():
|
||
for k, v in {
|
||
"pm_files": {},
|
||
"pm_custom_names": {},
|
||
"pm_results": [],
|
||
"pm_deposit": 10000.0,
|
||
"pm_running": False,
|
||
"pm_cancel": False,
|
||
"pm_thread_results": None,
|
||
"pm_progress_q": None,
|
||
"pm_uploader_key": 0,
|
||
}.items():
|
||
if k not in st.session_state:
|
||
st.session_state[k] = v
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# Render
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
def render():
|
||
_init_state()
|
||
|
||
st.markdown("""<style>
|
||
.pm-title{font-size:22px;font-weight:700;color:#CDD6F4;letter-spacing:.04em}
|
||
.pm-sub{font-size:13px;color:#6C7A8D;margin-bottom:14px}
|
||
.sh{font-size:11px;font-weight:600;color:#8899BB;text-transform:uppercase;
|
||
letter-spacing:.1em;margin:14px 0 6px;border-bottom:1px solid #1E2535;padding-bottom:4px}
|
||
.chip{display:inline-block;padding:3px 10px;border-radius:12px;font-size:11px;
|
||
font-weight:600;margin:2px;border:1px solid #2A3550;color:#8899CC}
|
||
.warn-box{background:#2A1A00;border:1px solid #7A4A00;border-radius:6px;
|
||
padding:10px 14px;font-size:13px;color:#FFB347;margin:8px 0}
|
||
</style>""", unsafe_allow_html=True)
|
||
|
||
_tc1, _tc2 = st.columns([8, 1])
|
||
with _tc1:
|
||
st.markdown('<p class="pm-title">🏆 Portfolio Master</p>', unsafe_allow_html=True)
|
||
st.markdown('<p class="pm-sub">Automated portfolio construction — composite scoring, greedy & Monte Carlo search</p>',
|
||
unsafe_allow_html=True)
|
||
with _tc2:
|
||
st.markdown("<br>", unsafe_allow_html=True)
|
||
if st.button("🗑 Clear", key="pm_clear_session", help="Clear all files and results to start fresh"):
|
||
st.session_state.pm_uploader_key = st.session_state.get("pm_uploader_key", 0) + 1
|
||
for _k in ["pm_files","pm_custom_names","pm_results","pm_running",
|
||
"pm_cancel","pm_thread_results","pm_progress_q","pm_cancel_event"]:
|
||
if _k in st.session_state:
|
||
del st.session_state[_k]
|
||
st.rerun()
|
||
|
||
# ── Upload ───────────────────────────────────────────────────────────────
|
||
with st.expander("📂 Upload Backtest Files",
|
||
expanded=not bool(st.session_state.pm_files)):
|
||
st.caption("Accepts `.htm` · `.html` · `.csv`")
|
||
uploaded = st.file_uploader(
|
||
"Select files", type=None, accept_multiple_files=True,
|
||
key=f"pm_uploader_{st.session_state.pm_uploader_key}",
|
||
)
|
||
if uploaded:
|
||
uploaded = [f for f in uploaded
|
||
if f.name.lower().endswith((".htm",".html",".csv"))]
|
||
for f in uploaded:
|
||
stem = os.path.splitext(f.name)[0]
|
||
if stem not in st.session_state.pm_files:
|
||
df = _parse_file(f)
|
||
if df is not None:
|
||
df = _normalise(df.copy(), stem)
|
||
st.session_state.pm_files[stem] = df
|
||
st.success(f"✅ **{stem}** — {len(df):,} trades")
|
||
|
||
if st.session_state.pm_files:
|
||
# Clear all button
|
||
if st.button("🗑 Clear All Files", key="pm_clear_all"):
|
||
st.session_state.pm_files = {}
|
||
st.session_state.pm_custom_names = {}
|
||
st.session_state.pm_results = []
|
||
st.rerun()
|
||
|
||
to_remove = []
|
||
for label in list(st.session_state.pm_files):
|
||
c1, c2 = st.columns([6,1])
|
||
c1.markdown(f"<span class='chip'>📈 {label}</span>", unsafe_allow_html=True)
|
||
if c2.button("✕", key=f"pmrm_{label}"):
|
||
to_remove.append(label)
|
||
for k in to_remove:
|
||
del st.session_state.pm_files[k]
|
||
st.session_state.pm_custom_names.pop(k, None)
|
||
st.rerun()
|
||
|
||
strategy_dfs: dict = st.session_state.pm_files
|
||
if not strategy_dfs:
|
||
st.info("Upload backtest files above to get started.")
|
||
return
|
||
|
||
labels = list(strategy_dfs.keys())
|
||
|
||
# ── Tabs ─────────────────────────────────────────────────────────────────
|
||
tab_config, tab_strategies, tab_results = st.tabs([
|
||
"⚙️ Configure & Run", "📊 Strategy Stats", "🏆 Results",
|
||
])
|
||
|
||
# ═════════════════════════════════════════════════════════════════════════
|
||
# CONFIGURE & RUN
|
||
# ═════════════════════════════════════════════════════════════════════════
|
||
with tab_config:
|
||
|
||
# ── Capital ──────────────────────────────────────────────────────────
|
||
st.markdown('<div class="sh">Capital</div>', unsafe_allow_html=True)
|
||
deposit = st.number_input("Initial Deposit ($)", min_value=100.0,
|
||
max_value=10_000_000.0,
|
||
value=st.session_state.pm_deposit,
|
||
step=1000.0, format="%.2f", key="pm_deposit")
|
||
|
||
# ── Composite score weights ───────────────────────────────────────────
|
||
st.markdown('<div class="sh">Composite Score Weights</div>', unsafe_allow_html=True)
|
||
st.caption("Weights are normalised automatically — they don't need to sum to 1.")
|
||
|
||
wc1, wc2, wc3, wc4 = st.columns([2, 2, 2, 3])
|
||
|
||
w_retdd = wc1.slider("Ret/DD", 0, 100, 35, key="pm_w_retdd")
|
||
w_stab = wc1.slider("Stability (R²)", 0, 100, 25, key="pm_w_stab")
|
||
w_stag = wc2.slider("Stagnation % ↓", 0, 100, 20, key="pm_w_stag",
|
||
help="Lower stagnation = higher score")
|
||
w_wr = wc2.slider("Win Rate", 0, 100, 10, key="pm_w_wr")
|
||
w_gq = wc3.slider("Growth Quality", 0, 100, 5, key="pm_w_gq",
|
||
help="Slope × R² — rewards a rising, stable equity curve")
|
||
w_div = wc3.slider("Diversity Bonus", 0, 100, 5, key="pm_w_div",
|
||
help="Rewards portfolios trading different symbols / sessions")
|
||
|
||
with wc4:
|
||
import os as _osw, re as _rew
|
||
_cfgw = _osw.path.join(_osw.path.dirname(_osw.path.abspath(__file__)), ".streamlit", "config.toml")
|
||
_lightw = False
|
||
if _osw.path.isfile(_cfgw):
|
||
_mw = _rew.search(r'base\s*=\s*"([^"]*)"', open(_cfgw).read())
|
||
if _mw: _lightw = _mw.group(1) == "light"
|
||
_wbg = "#f0f2f6" if _lightw else "#131720"
|
||
_wbdr = "#d0d4dc" if _lightw else "#1E2535"
|
||
_wtxt = "#555e70" if _lightw else "#8899AA"
|
||
_wlbl = "#1a1a2e" if _lightw else "#CDD6F4"
|
||
st.markdown(f"""
|
||
<div style="background:{_wbg};border:1px solid {_wbdr};border-radius:8px;
|
||
padding:10px 14px;font-size:11px;color:{_wtxt};line-height:1.8;margin-top:4px">
|
||
<b style="color:{_wlbl}">Ret/DD</b> — Net profit ÷ max drawdown. Primary return efficiency metric. Most important for risk-adjusted performance.<br>
|
||
<b style="color:{_wlbl}">Stability (R²)</b> — How straight the equity curve is. High R² means consistent gains without large swings.<br>
|
||
<b style="color:{_wlbl}">Stagnation ↓</b> — Time spent below a previous equity high, as % of total period. Lower = better; score is inverted.<br>
|
||
<b style="color:{_wlbl}">Win Rate</b> — Percentage of trades that are profitable. Higher win rate reduces psychological drawdown pressure.<br>
|
||
<b style="color:{_wlbl}">Growth Quality</b> — Combines equity curve slope with R². Rewards portfolios that rise steadily, not just flat and stable.<br>
|
||
<b style="color:{_wlbl}">Diversity Bonus</b> — Rewards combinations trading different symbols and/or different hours of the day.
|
||
</div>""", unsafe_allow_html=True)
|
||
|
||
total_w = w_retdd + w_stab + w_stag + w_wr + w_gq + w_div or 1
|
||
weights = {
|
||
"ret_dd": w_retdd / total_w,
|
||
"stability": w_stab / total_w,
|
||
"stagnation": w_stag / total_w,
|
||
"win_rate": w_wr / total_w,
|
||
"growth_quality": w_gq / total_w,
|
||
"diversity": w_div / total_w,
|
||
}
|
||
st.caption(f"Normalised: Ret/DD {weights['ret_dd']:.0%} "
|
||
f"Stability {weights['stability']:.0%} "
|
||
f"Stagnation {weights['stagnation']:.0%} "
|
||
f"Win Rate {weights['win_rate']:.0%} "
|
||
f"Growth Quality {weights['growth_quality']:.0%} "
|
||
f"Diversity {weights['diversity']:.0%}")
|
||
|
||
# ── Portfolio size ────────────────────────────────────────────────────
|
||
st.markdown('<div class="sh">Portfolio Size</div>', unsafe_allow_html=True)
|
||
sz1, sz2, sz3 = st.columns(3)
|
||
min_strats = sz1.number_input("Min strategies", min_value=1, max_value=len(labels),
|
||
value=2, step=1, key="pm_min")
|
||
max_strats = sz2.number_input("Max strategies", min_value=1, max_value=len(labels),
|
||
value=min(5, len(labels)), step=1, key="pm_max")
|
||
max_results = sz3.number_input("Max portfolios to store", min_value=1, max_value=500,
|
||
value=50, step=10, key="pm_maxres")
|
||
|
||
# ── Search mode ───────────────────────────────────────────────────────
|
||
st.markdown('<div class="sh">Search Mode</div>', unsafe_allow_html=True)
|
||
search_mode = st.radio(
|
||
"Algorithm",
|
||
["Exhaustive", "Greedy (fast)", "Monte Carlo", "Greedy + Monte Carlo"],
|
||
horizontal=True, key="pm_search_mode",
|
||
help="Exhaustive: every combination. Greedy: incremental build from each seed. "
|
||
"Monte Carlo: random sampling. Combined: greedy first then MC to fill gaps.",
|
||
)
|
||
|
||
mc_samples = 1000
|
||
if "Monte Carlo" in search_mode:
|
||
mc_samples = st.number_input("Monte Carlo samples", min_value=100,
|
||
max_value=100_000, value=5000,
|
||
step=500, key="pm_mc_samples")
|
||
|
||
# ── Combination count estimate + warning ─────────────────────────────
|
||
sel_labels = st.multiselect("Strategies to include", labels,
|
||
default=labels, key="pm_sel_labels")
|
||
n_sel = len(sel_labels)
|
||
|
||
if n_sel >= int(min_strats):
|
||
n_combos = _combo_estimate(n_sel, int(min_strats), int(max_strats))
|
||
t_estimate = _time_estimate(n_combos)
|
||
|
||
if search_mode == "Exhaustive":
|
||
col_est1, col_est2 = st.columns(2)
|
||
col_est1.metric("Combinations to evaluate", f"{n_combos:,}")
|
||
col_est2.metric("Estimated run time", t_estimate)
|
||
if n_combos > 50_000:
|
||
st.markdown(
|
||
f'<div class="warn-box">⚠️ <b>{n_combos:,} combinations</b> — '
|
||
f'estimated {t_estimate}. Consider switching to Greedy or Monte Carlo '
|
||
f'for faster results, or reduce Max strategies / Strategy count.</div>',
|
||
unsafe_allow_html=True)
|
||
elif n_combos > 5_000:
|
||
st.info(f"ℹ️ {n_combos:,} combinations — estimated {t_estimate}. "
|
||
f"This may take a moment.")
|
||
elif "Greedy" in search_mode:
|
||
st.metric("Greedy seeds (one per strategy)", n_sel)
|
||
else:
|
||
st.metric("Monte Carlo samples", f"{mc_samples:,}")
|
||
|
||
# ── Correlation ───────────────────────────────────────────────────────
|
||
st.markdown('<div class="sh">Correlation Filter</div>', unsafe_allow_html=True)
|
||
cc1, cc2 = st.columns(2)
|
||
use_corr = cc1.checkbox("Enable pairwise correlation filter", value=True, key="pm_use_corr")
|
||
use_cond = cc2.checkbox("Also compute conditional correlation (drawdown periods)",
|
||
value=True, key="pm_use_cond",
|
||
help="Shown in results but not used for filtering — "
|
||
"useful to see how strategies co-move during losses.")
|
||
corr_limit = st.slider("Max allowed pairwise correlation",
|
||
min_value=0.10, max_value=0.70, value=0.50,
|
||
step=0.05, key="pm_corr", disabled=not use_corr,
|
||
help="Portfolios with any pair exceeding this are excluded.")
|
||
|
||
# ── Date range ────────────────────────────────────────────────────────
|
||
st.markdown('<div class="sh">Date Range Filter</div>', unsafe_allow_html=True)
|
||
all_dates = [pd.to_datetime(df["close_time"]).dt.tz_localize(None).dropna()
|
||
for df in strategy_dfs.values() if "close_time" in df.columns]
|
||
date_from = date_to = None
|
||
if all_dates:
|
||
g_min = min(s.min().date() for s in all_dates)
|
||
g_max = max(s.max().date() for s in all_dates)
|
||
use_date = st.checkbox("Filter by date range", value=False, key="pm_use_date")
|
||
if use_date and g_min != g_max:
|
||
import datetime as _dt
|
||
total_days = (g_max - g_min).days
|
||
step = max(1, total_days // 500)
|
||
date_opts = [g_min + _dt.timedelta(days=i) for i in range(0, total_days+1, step)]
|
||
if date_opts[-1] != g_max: date_opts.append(g_max)
|
||
date_sel = st.select_slider("Date range", options=date_opts,
|
||
value=(g_min, g_max),
|
||
format_func=lambda d: d.strftime("%d %b %Y"),
|
||
key="pm_daterange")
|
||
date_from, date_to = date_sel
|
||
|
||
# ── Run ───────────────────────────────────────────────────────────────
|
||
st.markdown("---")
|
||
rb1, rb2 = st.columns([3, 1])
|
||
run_btn = rb1.button("🚀 Run Portfolio Search", type="primary",
|
||
key="pm_run",
|
||
disabled=st.session_state.pm_running)
|
||
cancel_btn = rb2.button("⛔ Cancel", key="pm_cancel_btn",
|
||
disabled=not st.session_state.pm_running)
|
||
|
||
if cancel_btn:
|
||
st.session_state.pm_cancel = True
|
||
# Signal the thread-safe event so the worker stops without session_state access
|
||
ev = st.session_state.get("pm_cancel_event")
|
||
if ev is not None:
|
||
ev.set()
|
||
|
||
# Poll for thread completion
|
||
if st.session_state.pm_running:
|
||
q = st.session_state.pm_progress_q
|
||
if q is not None:
|
||
import queue as _queue
|
||
try:
|
||
msg = q.get_nowait()
|
||
if msg.get("status") == "done":
|
||
st.session_state.pm_running = False
|
||
st.session_state.pm_cancel = False
|
||
results = msg.get("results", [])
|
||
st.session_state.pm_results = results
|
||
cancelled = msg.get("cancelled", False)
|
||
if cancelled:
|
||
st.warning(f"Search cancelled — {len(results)} portfolios found so far.")
|
||
else:
|
||
st.success(f"Found **{len(results)}** portfolios.")
|
||
elif msg.get("status") == "progress":
|
||
st.progress(msg["pct"], text=msg["text"])
|
||
except _queue.Empty:
|
||
pass
|
||
|
||
st.info("⏳ Search running… Results will appear when complete or cancelled.")
|
||
time.sleep(1)
|
||
st.rerun()
|
||
|
||
if run_btn:
|
||
if len(sel_labels) < int(min_strats):
|
||
st.error(f"Need at least {int(min_strats)} strategies selected.")
|
||
else:
|
||
filtered_dfs = {}
|
||
for lbl in sel_labels:
|
||
df = strategy_dfs[lbl].copy()
|
||
if date_from and date_to and "close_time" in df.columns:
|
||
ct = pd.to_datetime(df["close_time"]).dt.tz_localize(None)
|
||
df = df[(ct >= pd.Timestamp(date_from)) &
|
||
(ct <= pd.Timestamp(date_to) + timedelta(days=1))]
|
||
if not df.empty:
|
||
filtered_dfs[lbl] = df
|
||
|
||
if not filtered_dfs:
|
||
st.error("No data in selected date range.")
|
||
else:
|
||
import queue as _queue, threading as _threading
|
||
q = _queue.Queue()
|
||
cancel_event = _threading.Event() # thread-safe cancel flag
|
||
st.session_state.pm_progress_q = q
|
||
st.session_state.pm_cancel_event = cancel_event
|
||
st.session_state.pm_running = True
|
||
st.session_state.pm_cancel = False
|
||
|
||
# Capture all search params for the thread
|
||
_mode = search_mode
|
||
_labels = list(filtered_dfs.keys())
|
||
_fdfs = filtered_dfs
|
||
_dep = deposit
|
||
_wts = dict(weights)
|
||
_min_s = int(min_strats)
|
||
_max_s = int(max_strats)
|
||
_use_corr = use_corr
|
||
_corr_lim = corr_limit
|
||
_use_cond = use_cond
|
||
_max_res = int(max_results)
|
||
_mc_samp = int(mc_samples)
|
||
|
||
def _run_thread():
|
||
try:
|
||
cm = _correlation_matrix(_fdfs)
|
||
ccm = (_conditional_correlation(_fdfs, _dep) if _use_cond else cm)
|
||
|
||
def _prog(done, total, msg):
|
||
pct = min(done / max(total, 1), 1.0)
|
||
q.put({"status": "progress", "pct": pct, "text": msg})
|
||
|
||
def _is_cancelled():
|
||
return cancel_event.is_set() # no Streamlit context needed
|
||
|
||
if _mode == "Exhaustive":
|
||
res = _search_exhaustive(
|
||
_labels, _fdfs, _dep, _wts, _min_s, _max_s,
|
||
_use_corr, _corr_lim, cm, ccm, _max_res, _prog, _is_cancelled)
|
||
elif _mode == "Greedy (fast)":
|
||
res = _search_greedy(
|
||
_labels, _fdfs, _dep, _wts, _min_s, _max_s,
|
||
_use_corr, _corr_lim, cm, ccm, _max_res, _prog, _is_cancelled)
|
||
elif _mode == "Monte Carlo":
|
||
res = _search_montecarlo(
|
||
_labels, _fdfs, _dep, _wts, _min_s, _max_s,
|
||
_use_corr, _corr_lim, cm, ccm, _max_res, _mc_samp,
|
||
_prog, _is_cancelled)
|
||
else: # Greedy + Monte Carlo
|
||
gr = _search_greedy(
|
||
_labels, _fdfs, _dep, _wts, _min_s, _max_s,
|
||
_use_corr, _corr_lim, cm, ccm, _max_res, _prog, _is_cancelled)
|
||
mc = _search_montecarlo(
|
||
_labels, _fdfs, _dep, _wts, _min_s, _max_s,
|
||
_use_corr, _corr_lim, cm, ccm, _max_res, _mc_samp,
|
||
_prog, _is_cancelled)
|
||
seen = set(); combined = []
|
||
for r in sorted(gr + mc, key=lambda x: x["score"], reverse=True):
|
||
k = frozenset(r["members"])
|
||
if k not in seen: seen.add(k); combined.append(r)
|
||
res = combined[:_max_res]
|
||
|
||
q.put({"status": "done", "results": res,
|
||
"cancelled": _is_cancelled()})
|
||
except Exception as e:
|
||
q.put({"status": "done", "results": [],
|
||
"cancelled": False, "error": str(e)})
|
||
|
||
t = _threading.Thread(target=_run_thread, daemon=True)
|
||
t.start()
|
||
st.rerun()
|
||
|
||
# ═════════════════════════════════════════════════════════════════════════
|
||
# STRATEGY STATS
|
||
# ═════════════════════════════════════════════════════════════════════════
|
||
with tab_strategies:
|
||
st.markdown("##### Individual Strategy Statistics")
|
||
st.caption("Edit Strategy Name to assign custom names — these carry through to Results.")
|
||
|
||
dep_s = st.session_state.pm_deposit
|
||
rows = []
|
||
for i, label in enumerate(labels):
|
||
custom = st.session_state.pm_custom_names.get(label, "")
|
||
row = _full_stats(strategy_dfs[label], dep_s, i+1, custom)
|
||
if row: rows.append(row)
|
||
|
||
if rows:
|
||
col_order = ["#","Strategy Name","Symbol","# Trades",
|
||
"Net Profit ($)","Max DD ($)","Max DD (%)",
|
||
"Annual Profit ($)","Annual Profit (%)",
|
||
"Avg Win ($)","Avg Loss ($)","% Wins",
|
||
"Commissions ($)",
|
||
"Stagnation (%)","Stagnation (days)","Profit Factor",
|
||
"Ret/DD","Stability","Growth Quality"]
|
||
stats_df = pd.DataFrame(rows)
|
||
stats_df = stats_df[[c for c in col_order if c in stats_df.columns]]
|
||
|
||
edited = st.data_editor(
|
||
stats_df, use_container_width=True, hide_index=True,
|
||
column_config={
|
||
"#": st.column_config.NumberColumn("#", disabled=True, width="small"),
|
||
"Strategy Name": st.column_config.TextColumn("Strategy Name", width="medium"),
|
||
"Symbol": st.column_config.TextColumn("Symbol", disabled=True),
|
||
"# Trades": st.column_config.NumberColumn("# Trades", disabled=True, format="%d"),
|
||
"Net Profit ($)": st.column_config.NumberColumn("Net Profit ($)", disabled=True, format="%.2f"),
|
||
"Max DD ($)": st.column_config.NumberColumn("Max DD ($)", disabled=True, format="%.2f"),
|
||
"Max DD (%)": st.column_config.NumberColumn("Max DD (%)", disabled=True, format="%.2f"),
|
||
"Annual Profit ($)": st.column_config.NumberColumn("Annual Profit ($)", disabled=True, format="%.2f"),
|
||
"Annual Profit (%)": st.column_config.NumberColumn("Annual Profit (%)", disabled=True, format="%.2f"),
|
||
"Avg Win ($)": st.column_config.NumberColumn("Avg Win ($)", disabled=True, format="%.2f"),
|
||
"Avg Loss ($)": st.column_config.NumberColumn("Avg Loss ($)", disabled=True, format="%.2f"),
|
||
"% Wins": st.column_config.NumberColumn("% Wins", disabled=True, format="%.2f"),
|
||
"Commissions ($)": st.column_config.NumberColumn("Commissions ($)", disabled=True, format="%.2f"),
|
||
"Stagnation (%)": st.column_config.NumberColumn("Stagnation (%)", disabled=True, format="%.2f"),
|
||
"Stagnation (days)": st.column_config.NumberColumn("Stagnation (d)", disabled=True, format="%d"),
|
||
"Profit Factor": st.column_config.NumberColumn("PF", disabled=True, format="%.2f"),
|
||
"Ret/DD": st.column_config.NumberColumn("Ret/DD", disabled=True, format="%.2f"),
|
||
"Stability": st.column_config.NumberColumn("Stability", disabled=True, format="%d",
|
||
help="R² of equity curve linear regression. 1.0 = perfectly straight."),
|
||
"Growth Quality": st.column_config.NumberColumn("Growth Quality", disabled=True, format="%d",
|
||
help="Normalised slope × R² — rewards a consistently rising equity curve."),
|
||
},
|
||
key="pm_stats_editor",
|
||
)
|
||
for _, row in edited.iterrows():
|
||
orig = labels[int(row["#"]) - 1]
|
||
name = str(row["Strategy Name"]).strip()
|
||
if name and name != orig: st.session_state.pm_custom_names[orig] = name
|
||
else: st.session_state.pm_custom_names.pop(orig, None)
|
||
|
||
# Overall correlation heatmap
|
||
if len(labels) > 1:
|
||
hc1, hc2 = st.columns(2)
|
||
with hc1:
|
||
st.markdown("##### Pairwise Correlation (all days)")
|
||
corr = _correlation_matrix(strategy_dfs)
|
||
disp_labels = [st.session_state.pm_custom_names.get(l,l) for l in corr.columns]
|
||
corr.index = corr.columns = disp_labels
|
||
st.plotly_chart(_corr_fig(corr, height=max(300, len(labels)*55)),
|
||
use_container_width=True, key=f"pm_corr_all_{len(labels)}")
|
||
with hc2:
|
||
st.markdown("##### Conditional Correlation (drawdown days only)")
|
||
dep_s2 = st.session_state.pm_deposit
|
||
cond = _conditional_correlation(strategy_dfs, dep_s2)
|
||
cond.index = cond.columns = disp_labels
|
||
st.plotly_chart(_corr_fig(cond, height=max(300, len(labels)*55)),
|
||
use_container_width=True, key=f"pm_corr_cond_{len(labels)}")
|
||
|
||
# ═════════════════════════════════════════════════════════════════════════
|
||
# RESULTS
|
||
# ═════════════════════════════════════════════════════════════════════════
|
||
with tab_results:
|
||
results = st.session_state.pm_results
|
||
if not results:
|
||
st.info("Run the portfolio search on the Configure tab first.")
|
||
else:
|
||
def _name(lbl):
|
||
return st.session_state.pm_custom_names.get(lbl, lbl)
|
||
|
||
# ── Summary table ─────────────────────────────────────────────────
|
||
st.markdown(f"##### Top {len(results)} Portfolios")
|
||
import os as _os2, re as _re3
|
||
_cfg2 = _os2.path.join(_os2.path.dirname(_os2.path.abspath(__file__)), ".streamlit", "config.toml")
|
||
_light2 = False
|
||
if _os2.path.isfile(_cfg2):
|
||
_m2 = _re3.search(r'base\s*=\s*"([^"]*)"', open(_cfg2).read())
|
||
if _m2: _light2 = _m2.group(1) == "light"
|
||
_desc_bg = "#f0f2f6" if _light2 else "#131720"
|
||
_desc_border = "#d0d4dc" if _light2 else "#1E2535"
|
||
_desc_text = "#555e70" if _light2 else "#8899AA"
|
||
_desc_label = "#1a1a2e" if _light2 else "#CDD6F4"
|
||
_desc_thresh = lambda good, warn: (
|
||
f'<span style="color:#34C27A">{good}</span> | ' +
|
||
f'<span style="color:#f77f00">{warn}</span> | ' +
|
||
f'<span style="color:#E05555">below = poor</span>'
|
||
)
|
||
st.markdown(f"""
|
||
<div style="background:{_desc_bg};border:1px solid {_desc_border};border-radius:8px;padding:12px 16px;font-size:12px;color:{_desc_text};margin-bottom:12px;line-height:1.9">
|
||
<b style="color:{_desc_label}">Score</b> — Composite ranking (0–1000). Higher is better. Weighted blend of the metrics below based on your sliders.
|
||
<span style="color:#34C27A">≥700 = strong</span> | <span style="color:#f77f00">400–700 = average</span> | <span style="color:#E05555"><400 = weak</span><br>
|
||
<b style="color:{_desc_label}">Ret/DD</b> — Net profit divided by max drawdown. Measures return efficiency per unit of risk.
|
||
<span style="color:#34C27A">≥5 = strong</span> | <span style="color:#f77f00">2–5 = average</span> | <span style="color:#E05555"><2 = weak</span><br>
|
||
<b style="color:{_desc_label}">Stability</b> — How straight the equity curve is (0–100). 100 = perfectly straight rising line. R² of linear regression on the equity curve.
|
||
<span style="color:#34C27A">≥70 = strong</span> | <span style="color:#f77f00">40–70 = average</span> | <span style="color:#E05555"><40 = weak</span><br>
|
||
<b style="color:{_desc_label}">Growth Quality</b> — Combines curve straightness with upward slope. Rewards portfolios that rise consistently, not just ones that are flat and stable.
|
||
<span style="color:#34C27A">≥50 = strong</span> | <span style="color:#f77f00">20–50 = average</span> | <span style="color:#E05555"><20 = weak</span><br>
|
||
<b style="color:{_desc_label}">Diversity</b> — How different the strategies are from each other (0–100), based on symbol variety and trading session overlap. 100 = completely different.
|
||
<span style="color:#34C27A">≥60 = strong</span> | <span style="color:#f77f00">30–60 = average</span> | <span style="color:#E05555"><30 = low diversity</span><br>
|
||
<b style="color:{_desc_label}">Avg Corr</b> — Average pairwise correlation of daily P&L. Lower is better — strategies that don't move together reduce portfolio drawdown.
|
||
<span style="color:#34C27A">≤0.20 = low (good)</span> | <span style="color:#f77f00">0.20–0.50 = moderate</span> | <span style="color:#E05555">>0.50 = high (bad)</span><br>
|
||
<b style="color:{_desc_label}">Avg Cond Corr</b> — Same correlation computed only on drawdown days. Strategies that decorrelate during losses are more valuable.
|
||
<span style="color:#34C27A">≤0.20 = low (good)</span> | <span style="color:#f77f00">0.20–0.50 = moderate</span> | <span style="color:#E05555">>0.50 = high (bad)</span>
|
||
</div>
|
||
""", unsafe_allow_html=True)
|
||
|
||
col_order = [
|
||
"Rank", "Score", "Strategies", "# Strategies",
|
||
"Avg Corr", "Avg Cond Corr", "Diversity",
|
||
"# Trades", "Net Profit ($)", "Max DD ($)", "Max DD (%)",
|
||
"Annual Profit ($)", "Annual Profit (%)",
|
||
"Avg Win ($)", "Avg Loss ($)", "% Wins",
|
||
"Commissions ($)",
|
||
"Stagnation (%)", "Stagnation (days)", "Profit Factor",
|
||
"Ret/DD", "Stability", "Growth Quality",
|
||
]
|
||
rows_r = []
|
||
for i, r in enumerate(results):
|
||
member_names = " + ".join(_name(m) for m in r["members"])
|
||
fs = r.get("full_stats", {})
|
||
row = {
|
||
"Rank": i + 1,
|
||
"Score": round(r.get("score", 0), 4),
|
||
"Strategies": member_names,
|
||
"# Strategies": len(r["members"]),
|
||
"Avg Corr": round(r.get("avg_corr", 0), 4),
|
||
"Avg Cond Corr":round(r.get("avg_cond_corr", 0), 4),
|
||
"Diversity": round(r.get("diversity", 0), 4),
|
||
}
|
||
for col in col_order[7:]:
|
||
row[col] = fs.get(col, 0)
|
||
rows_r.append(row)
|
||
|
||
res_df = pd.DataFrame(rows_r)
|
||
res_df = res_df[[c for c in col_order if c in res_df.columns]]
|
||
|
||
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 ""
|
||
|
||
int_cols = {"Rank","# Strategies","# Trades","Stagnation (days)"}
|
||
nc = res_df.select_dtypes(include="number").columns.tolist()
|
||
fmt = {c: ("{:.0f}" if c in int_cols or c in
|
||
("Score","Stability","Growth Quality","Diversity")
|
||
else "{:.3f}" if c in ("Avg Corr","Avg Cond Corr")
|
||
else "{:.2f}") for c in nc}
|
||
|
||
pos_cols = [c for c in ["Net Profit ($)","Annual Profit ($)","Annual Profit (%)","Avg Win ($)","Score"]
|
||
if c in res_df.columns]
|
||
neg_cols = [c for c in ["Max DD ($)","Max DD (%)","Avg Loss ($)","Avg Corr","Avg Cond Corr"]
|
||
if c in res_df.columns]
|
||
|
||
def _grade(val, good, avg):
|
||
"""Return green/orange/red based on good/avg thresholds (higher=better)."""
|
||
if not isinstance(val, (int, float)): return ""
|
||
if val >= good: return "background-color:rgba(52,194,122,0.15);color:#34C27A"
|
||
if val >= avg: return "background-color:rgba(247,127,0,0.12);color:#f77f00"
|
||
return "background-color:rgba(220,50,50,0.12);color:#E05555"
|
||
|
||
def _grade_inv(val, good, avg):
|
||
"""Return green/orange/red — lower is better (correlation)."""
|
||
if not isinstance(val, (int, float)): return ""
|
||
if val <= good: return "background-color:rgba(52,194,122,0.15);color:#34C27A"
|
||
if val <= avg: return "background-color:rgba(247,127,0,0.12);color:#f77f00"
|
||
return "background-color:rgba(220,50,50,0.12);color:#E05555"
|
||
|
||
styled = (
|
||
res_df.style.format(fmt)
|
||
.map(_cc, subset=pos_cols if pos_cols else [])
|
||
.map(lambda v: "color:#E05555" if isinstance(v,(int,float)) and v < 0 else "",
|
||
subset=neg_cols if neg_cols else [])
|
||
.map(lambda v: _cc(v, 1.0),
|
||
subset=["Profit Factor"] if "Profit Factor" in res_df.columns else [])
|
||
.map(lambda v: _grade(v, 700, 400),
|
||
subset=["Score"] if "Score" in res_df.columns else [])
|
||
.map(lambda v: _grade(v, 5, 2),
|
||
subset=["Ret/DD"] if "Ret/DD" in res_df.columns else [])
|
||
.map(lambda v: _grade(v, 70, 40),
|
||
subset=["Stability"] if "Stability" in res_df.columns else [])
|
||
.map(lambda v: _grade(v, 50, 20),
|
||
subset=["Growth Quality"] if "Growth Quality" in res_df.columns else [])
|
||
.map(lambda v: _grade(v, 60, 30),
|
||
subset=["Diversity"] if "Diversity" in res_df.columns else [])
|
||
.map(lambda v: _grade_inv(v, 0.20, 0.50),
|
||
subset=["Avg Corr"] if "Avg Corr" in res_df.columns else [])
|
||
.map(lambda v: _grade_inv(v, 0.20, 0.50),
|
||
subset=["Avg Cond Corr"] if "Avg Cond Corr" in res_df.columns else [])
|
||
)
|
||
st.dataframe(styled, use_container_width=True, hide_index=True)
|
||
|
||
buf = io.StringIO(); res_df.to_csv(buf, index=False)
|
||
st.download_button("⬇️ Export Results CSV", buf.getvalue(),
|
||
file_name="portfolio_master_results.csv", mime="text/csv")
|
||
|
||
# ── Detail expanders ──────────────────────────────────────────────
|
||
st.markdown("##### Portfolio Detail")
|
||
show_top = st.slider("Show detail for top N", 1, min(10, len(results)),
|
||
min(5, len(results)), key="pm_show_top")
|
||
|
||
for i, r in enumerate(results[:show_top]):
|
||
member_names = " + ".join(_name(m) for m in r["members"])
|
||
with st.expander(
|
||
f"#{i+1} {member_names} "
|
||
f"| Score {r['score']:.4f} "
|
||
f"| Ret/DD {r['ret_dd']:.2f} "
|
||
f"| Net ${r['net_profit']:,.2f} "
|
||
f"| DD ${r['max_dd']:,.2f}"
|
||
):
|
||
# Key metrics row
|
||
mc1,mc2,mc3,mc4,mc5,mc6 = st.columns(6)
|
||
mc1.metric("Score", f"{r['score']:.4f}")
|
||
mc2.metric("Ret/DD", f"{r['ret_dd']:.2f}")
|
||
mc3.metric("Stability", f"{r['stability']}")
|
||
mc4.metric("Growth Quality", f"{r['growth_quality']}")
|
||
mc5.metric("Avg Correlation",f"{r['avg_corr']:.3f}")
|
||
mc6.metric("Avg Cond Corr", f"{r['avg_cond_corr']:.3f}",
|
||
help="Correlation during drawdown days only")
|
||
|
||
dc1, dc2 = st.columns(2)
|
||
|
||
# Mini equity chart
|
||
with dc1:
|
||
frames = [strategy_dfs[m].copy() for m in r["members"] if m in strategy_dfs]
|
||
if frames:
|
||
combined = pd.concat(frames, ignore_index=True)
|
||
if "close_time" in combined.columns:
|
||
combined = combined.sort_values("close_time").reset_index(drop=True)
|
||
eq = st.session_state.pm_deposit + combined["net_profit"].cumsum()
|
||
rm = eq.cummax(); dd_c = eq - rm
|
||
pfig = go.Figure()
|
||
pfig.add_trace(go.Scatter(x=combined["close_time"], y=eq,
|
||
name="Equity", line=dict(color="#4C8EF5", width=2), mode="lines"))
|
||
pfig.add_trace(go.Scatter(x=combined["close_time"], y=dd_c,
|
||
name="DD", fill="tozeroy",
|
||
fillcolor="rgba(220,50,50,0.25)",
|
||
line=dict(color="rgba(220,50,50,0.6)", width=1),
|
||
mode="lines", yaxis="y2"))
|
||
pfig.update_layout(
|
||
height=200, margin=dict(l=40,r=40,t=10,b=10),
|
||
paper_bgcolor="rgba(0,0,0,0)", plot_bgcolor="#0E1117",
|
||
hovermode="x unified",
|
||
legend=dict(orientation="h", y=1.1, font=dict(size=9)),
|
||
yaxis=dict(gridcolor="#1E2130", tickprefix="$"),
|
||
yaxis2=dict(overlaying="y", side="right",
|
||
gridcolor="#1E2130", tickprefix="$", showgrid=False),
|
||
)
|
||
# Add invisible annotation to ensure figure hash is unique per portfolio
|
||
pfig.add_annotation(text=str(i), x=0, y=0, opacity=0,
|
||
showarrow=False, xref="paper", yref="paper")
|
||
st.plotly_chart(pfig, use_container_width=True, key=f"pm_pfig_{i}")
|
||
|
||
# Per-result correlation heatmap
|
||
with dc2:
|
||
if len(r["members"]) > 1:
|
||
member_dfs = {m: strategy_dfs[m] for m in r["members"] if m in strategy_dfs}
|
||
if len(member_dfs) > 1:
|
||
r_corr = _correlation_matrix(member_dfs)
|
||
r_cond = _conditional_correlation(member_dfs, st.session_state.pm_deposit)
|
||
disp = [_name(m) for m in r_corr.columns]
|
||
r_corr.index = r_corr.columns = disp
|
||
r_cond.index = r_cond.columns = disp
|
||
st.plotly_chart(
|
||
_corr_fig(r_corr, title="Correlation (all days)", height=180),
|
||
use_container_width=True, key=f"pm_rcorr_{i}")
|
||
st.plotly_chart(
|
||
_corr_fig(r_cond, title="Conditional (DD days)", height=180),
|
||
use_container_width=True, key=f"pm_rcond_{i}")
|
||
|
||
# Member stats table
|
||
m_rows = []
|
||
for m in r["members"]:
|
||
if m not in strategy_dfs: continue
|
||
s = _full_stats(strategy_dfs[m], st.session_state.pm_deposit,
|
||
labels.index(m)+1,
|
||
st.session_state.pm_custom_names.get(m,""))
|
||
if s:
|
||
m_rows.append({
|
||
"Strategy": s.get("Strategy Name", m),
|
||
"Symbol": s.get("Symbol",""),
|
||
"Net Profit ($)": s.get("Net Profit ($)",0),
|
||
"Max DD ($)": s.get("Max DD ($)",0),
|
||
"Ret/DD": s.get("Ret/DD",0),
|
||
"% Wins": s.get("% Wins",0),
|
||
"Profit Factor": s.get("Profit Factor",0),
|
||
"Stability": s.get("Stability",0),
|
||
"Growth Quality": s.get("Growth Quality",0),
|
||
})
|
||
if m_rows:
|
||
mdf = pd.DataFrame(m_rows)
|
||
st.dataframe(
|
||
mdf.style.format({c:"{:.0f}" if c in ("Stability","Growth Quality")
|
||
else "{:.2f}"
|
||
for c in mdf.select_dtypes("number").columns}),
|
||
use_container_width=True, hide_index=True) |