fcostalonga/Ottimizzatore
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Allineamento alla versione principale

Browse Source
This commit is contained in:
fredmaloggia
2025-11-24 15:03:18 +01:00
parent c816f5820b
commit 906484cb11
7 changed files with 232 additions and 816 deletions
Download Patch File Download Diff File Expand all files Collapse all files

190
Sviluppo/20251022 Ottimizzatore Versione 2.6 - R^2.py
View File

@@ -13,8 +13,6 @@ import os
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from dotenv import load_dotenv
import yaml
from sqlalchemy import create_engine, text
from sqlalchemy.exc import SQLAlchemyError
@@ -27,12 +25,10 @@ from pypfopt.exceptions import OptimizationError
OUTPUT_DIR = "Output"
INPUT_DIR = "Input"
PLOT_DIR = "Plot"
CONFIG_FILE = "config.yaml"
os.makedirs(OUTPUT_DIR, exist_ok=True)
os.makedirs(INPUT_DIR, exist_ok=True)
os.makedirs(PLOT_DIR, exist_ok=True)
load_dotenv()
def excel_path(filename: str) -> str:
"""Percorso completo per i file Excel di output."""
@@ -47,60 +43,23 @@ optimized_weights_phase2 = pd.DataFrame()
summary_data_phase2 = []
# =========================
# CONFIGURAZIONE OBIETTIVI (da config.yaml con fallback)
# CONFIGURAZIONE OBIETTIVI
# =========================
DEFAULT_VOL_TARGETS = [
{"years": 5, "target_vol": 0.06, "name": "VAR3_5Y"},
{"years": 1, "target_vol": 0.12, "name": "VAR6_1Y"},
{"years": 3, "target_vol": 0.12, "name": "VAR6_3Y"},
{"years": 5, "target_vol": 0.12, "name": "VAR6_5Y"},
{"years": 5, "target_vol": 0.18, "name": "VAR9_5Y"},
]
DEFAULT_ASSET_CLASS_LIMITS = {
'Azionari': 0.75, 'Obbligazionari': 0.75,
'Metalli Preziosi': 0.20, 'Materie Prime': 0.05,
'Immobiliare': 0.05, 'Criptovalute': 0.05, 'Monetari': 0.10
volatility_targets = {
# (1, 0.06): 'VAR3_1Y',
# (3, 0.06): 'VAR3_3Y',
(5, 0.06): 'VAR3_5Y',
(1, 0.12): 'VAR6_1Y',
(3, 0.12): 'VAR6_3Y',
(5, 0.12): 'VAR6_5Y',
# (1, 0.18): 'VAR9_1Y',
# (3, 0.18): 'VAR9_3Y',
(5, 0.18): 'VAR9_5Y'
}
def load_targets_and_limits(config_file: str, profile: str = "default"):
"""Legge target di volatilità e limiti asset class dal file di configurazione."""
cfg = {}
try:
with open(config_file, "r", encoding="utf-8") as f:
cfg = yaml.safe_load(f) or {}
except FileNotFoundError:
cfg = {}
vt_cfg = cfg.get("volatility_targets", {})
vt_list = []
if isinstance(vt_cfg, dict):
vt_list = vt_cfg.get(profile) or vt_cfg.get("default") or []
elif isinstance(vt_cfg, list):
vt_list = vt_cfg
if not vt_list:
vt_list = DEFAULT_VOL_TARGETS
volatility_targets_local = {
(int(item["years"]), float(item["target_vol"])): item["name"]
for item in vt_list
if "years" in item and "target_vol" in item and "name" in item
}
asset_limits_cfg = cfg.get("asset_class_limits") or {}
if not asset_limits_cfg:
asset_limits_cfg = DEFAULT_ASSET_CLASS_LIMITS
asset_class_limits_local = {k: float(v) for k, v in asset_limits_cfg.items()}
return volatility_targets_local, asset_class_limits_local
CONFIG_PROFILE = os.getenv("CONFIG_PROFILE", "default")
volatility_targets, asset_class_limits_cfg = load_targets_and_limits(CONFIG_FILE, CONFIG_PROFILE)
days_per_year = 252
riskfree_rate = 0.02
mu_ph2_floor = 0.9
GAP_FFILL_LIMIT_DAYS = 5 # forward-fill limit per buchi di calendario
# ---------------------------------
# Utility per R^2 sull’equity line
@@ -356,85 +315,6 @@ df = pd.read_excel(
dtype={'Codice Titolo': str}
)
# =========================
# VALIDAZIONE DATI RENDIMENTI
# =========================
def _gap_ranges_missing(series: pd.Series, all_dates: pd.DatetimeIndex, max_entries: int = 3):
"""Restituisce fino a max_entries intervalli di date mancanti (start, end, len)."""
missing_idx = series[series.isna()].index
if missing_idx.empty:
return []
positions = [all_dates.get_loc(ts) for ts in missing_idx if ts in all_dates]
if not positions:
return []
ranges = []
start_pos = positions[0]
end_pos = positions[0]
for pos in positions[1:]:
if pos == end_pos + 1:
end_pos = pos
else:
ranges.append((all_dates[start_pos], all_dates[end_pos], end_pos - start_pos + 1))
start_pos = end_pos = pos
ranges.append((all_dates[start_pos], all_dates[end_pos], end_pos - start_pos + 1))
return ranges[:max_entries]
def preprocess_returns(temp_df: pd.DataFrame, isin: str, all_dates: pd.DatetimeIndex,
gap_ffill_limit: int = GAP_FFILL_LIMIT_DAYS) -> pd.Series:
"""Pulizia/validazione serie rendimenti (tipi, duplicati, buchi, niente fillna(0))."""
required_cols = {"Px_Date", "RendimentoGiornaliero"}
missing_cols = required_cols.difference(temp_df.columns)
if missing_cols:
print(f"[{isin}] Colonne mancanti {missing_cols}, asset ignorato.")
return pd.Series(dtype=float)
df_local = temp_df.copy()
df_local["Px_Date"] = pd.to_datetime(df_local["Px_Date"], errors="coerce").dt.normalize()
df_local["RendimentoGiornaliero"] = pd.to_numeric(df_local["RendimentoGiornaliero"], errors="coerce")
before_rows = len(df_local)
df_local = df_local.dropna(subset=["Px_Date", "RendimentoGiornaliero"])
dropped_na = before_rows - len(df_local)
dup_count = df_local.duplicated(subset=["Px_Date"]).sum()
if dup_count > 0:
print(f"[{isin}] Drop duplicati su Px_Date: {dup_count}")
df_local = df_local.drop_duplicates(subset=["Px_Date"], keep="last").sort_values("Px_Date")
if df_local.empty:
print(f"[{isin}] Nessuna riga valida dopo cleaning, asset ignorato.")
return pd.Series(dtype=float)
df_local["RendimentoGiornaliero"] = df_local["RendimentoGiornaliero"] / 100.0
series = df_local.set_index("Px_Date")["RendimentoGiornaliero"].reindex(all_dates)
missing_before_fill = int(series.isna().sum())
if missing_before_fill > 0:
gaps = _gap_ranges_missing(series, all_dates, max_entries=3)
if gaps:
gaps_str = "; ".join([f"{g[0].date()}->{g[1].date()} ({g[2]} gg)" for g in gaps])
print(f"[{isin}] Date mancanti prima del fill (prime): {gaps_str}")
series_ffill = series.ffill(limit=gap_ffill_limit)
first_valid = series_ffill.first_valid_index()
last_valid = series_ffill.last_valid_index()
if first_valid is None or last_valid is None:
print(f"[{isin}] Serie vuota dopo forward-fill, asset ignorato.")
return pd.Series(dtype=float)
series_ffill = series_ffill.loc[first_valid:last_valid]
residual_missing = int(series_ffill.isna().sum())
if residual_missing > 0:
print(f"[{isin}] {residual_missing} valori mancanti non coperti dal forward-fill (limite {gap_ffill_limit}), righe scartate.")
series_ffill = series_ffill.dropna()
coverage_days = series_ffill.shape[0]
if dropped_na > 0 or missing_before_fill > 0:
print(f"[{isin}] Righe totali: {before_rows}, drop NA: {dropped_na}, copertura finale: {coverage_days} giorni.")
return series_ffill
# =========================
# SERIE STORICHE RENDIMENTI
# =========================
@@ -453,23 +333,17 @@ for isin in df['ISIN'].unique():
if temp_df.empty:
print(f"Nessun dato recuperato per {isin}, skipping...")
continue
clean_series = preprocess_returns(temp_df, isin, all_dates, gap_ffill_limit=GAP_FFILL_LIMIT_DAYS)
if clean_series.empty:
print(f"Nessun dato valido per {isin} dopo la validazione, asset ignorato.")
continue
final_df[isin] = clean_series.reindex(all_dates)
temp_df['Px_Date'] = pd.to_datetime(temp_df['Px_Date'], format='%Y-%m-%d', errors='coerce').dt.normalize()
temp_df = temp_df.dropna(subset=['Px_Date'])
temp_df.set_index('Px_Date', inplace=True)
temp_df['RendimentoGiornaliero'] = temp_df['RendimentoGiornaliero'] / 100
final_df[isin] = temp_df['RendimentoGiornaliero'].reindex(all_dates)
isin_from_db.add(isin)
non_null = int(final_df[isin].count())
missing_left = int(final_df[isin].isna().sum())
print(f"Dati recuperati per {isin}: {non_null} righe valide, mancanti residui: {missing_left}.")
print(f"Dati recuperati per {isin}: {final_df[isin].count()} righe di dati non-null prelevate.")
except SQLAlchemyError as e:
print(f"Errore durante l'esecuzione della stored procedure per {isin}:", e)
final_df = final_df.loc[:, final_df.notna().any()] # elimina asset senza dati utili
if final_df.shape[1] == 0:
print("Nessun ISIN valido dopo la validazione dei rendimenti, uscita.")
sys.exit(1)
final_df = final_df.dropna(how='all')
final_df.fillna(0, inplace=True)
# -------- H_min sempre su 5 anni (21 gg = 1 mese) --------
five_year_df = final_df.loc[end_date - pd.DateOffset(years=5): end_date]
@@ -564,7 +438,12 @@ for (years, target_vol), name in volatility_targets.items():
ef.add_constraint(lambda w, idxs=idxs, maxw=maxw: sum(w[i] for i in idxs) <= maxw)
# Vincoli per Asset Class
for ac, maxw in asset_class_limits_cfg.items():
asset_class_limits = {
'Azionari': 0.75, 'Obbligazionari': 0.75,
'Metalli Preziosi': 0.20, 'Materie Prime': 0.05,
'Immobiliare': 0.05, 'Criptovalute': 0.05, 'Monetari': 0.1
}
for ac, maxw in asset_class_limits.items():
isin_list = df[df['Asset Class'] == ac]['ISIN'].tolist()
idxs = [period_df.columns.get_loc(isin) for isin in isin_list if isin in period_df.columns]
if idxs:
@@ -605,16 +484,13 @@ for (years, target_vol), name in volatility_targets.items():
results_rows.append(row)
results_full_df = pd.DataFrame(results_rows, columns=template_cols)
if results_full_df.empty:
output_df = template_df.iloc[0:0].copy()
else:
output_df = results_full_df.reindex(columns=template_cols)
output_df = pd.concat([template_df.iloc[0:0], results_full_df], ignore_index=True)
output_file_path = excel_path(f'PTFOPT{name}.xlsx')
output_df.to_excel(output_file_path, index=False)
print(f"File {output_file_path} saved successfully.")
# --- Pie chart asset allocation (se ci sono pesi > 0) ---
asset_allocations = {asset: 0 for asset in asset_class_limits_cfg}
asset_allocations = {asset: 0 for asset in asset_class_limits}
for isin, weight in weights.items():
r_sel = df.loc[df['ISIN'] == isin]
if r_sel.empty:
@@ -831,7 +707,12 @@ if cp is not None:
if idxs:
ef_h.add_constraint(lambda w, idxs=idxs, maxw=maxw: cp.sum(w[idxs]) <= maxw)
for ac, maxw in asset_class_limits_cfg.items():
asset_class_limits = {
'Azionari': 0.75, 'Obbligazionari': 0.75,
'Metalli Preziosi': 0.20, 'Materie Prime': 0.05,
'Immobiliare': 0.05, 'Criptovalute': 0.05, 'Monetari': 0.1
}
for ac, maxw in asset_class_limits.items():
isin_list = df[df['Asset Class'] == ac]['ISIN'].tolist()
idxs = [period_df_p.columns.get_loc(isin) for isin in isin_list if isin in period_df_p.columns]
if idxs:
@@ -992,12 +873,9 @@ else:
row['peso'] = float(weight * 99) # allineato a Fase 1
results_rows.append(row)
# Prepara il foglio con l'intestazione del template + righe risultato
# Prepara il foglio con l’intestazione del template + righe risultato
results_full_df = pd.DataFrame(results_rows, columns=template_cols)
if results_full_df.empty:
output_df = template_df.iloc[0:0].copy()
else:
output_df = results_full_df.reindex(columns=template_cols)
output_df = pd.concat([template_df.iloc[0:0], results_full_df], ignore_index=True)
# NOME FILE: identico al naming di Fase 1
output_file_path = excel_path(f'PTFOPT{name}_PH2.xlsx')

183
Sviluppo/20251022 Ottimizzatore Versione 2.6.py
View File

@@ -15,6 +15,7 @@ import pandas as pd
import matplotlib.pyplot as plt
from dotenv import load_dotenv
import yaml
import logging
from sqlalchemy import create_engine, text
from sqlalchemy.exc import SQLAlchemyError
@@ -33,6 +34,8 @@ os.makedirs(OUTPUT_DIR, exist_ok=True)
os.makedirs(INPUT_DIR, exist_ok=True)
os.makedirs(PLOT_DIR, exist_ok=True)
load_dotenv()
logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
logger = logging.getLogger(__name__)
def excel_path(filename: str) -> str:
"""Percorso completo per i file Excel di output."""
@@ -47,7 +50,7 @@ optimized_weights_phase1_heal = pd.DataFrame()
summary_data_phase1_heal = []
# =========================
# CONFIGURAZIONE OBIETTIVI (da config.yaml con fallback)
# CONFIGURAZIONE OBIETTIVI (config esterna + fallback) E VALIDAZIONE
# =========================
DEFAULT_VOL_TARGETS = [
{"years": 5, "target_vol": 0.06, "name": "VAR3_5Y"},
@@ -101,7 +104,30 @@ days_per_year = 252
riskfree_rate = 0.02
mu_heal_floor = 0.85
GAP_FFILL_LIMIT_DAYS = 5 # forward-fill limit per buchi di calendario
def validate_universe(df_universe: pd.DataFrame):
required_cols = ['ISIN', 'Nome', 'Categoria', 'Asset Class']
missing_cols = [c for c in required_cols if c not in df_universe.columns]
if missing_cols:
logger.error("Colonne mancanti nel file universo: %s", ", ".join(missing_cols))
sys.exit(1)
dup_isin = df_universe['ISIN'][df_universe['ISIN'].duplicated()].unique().tolist()
if dup_isin:
logger.warning("ISIN duplicati nel file universo: %s", dup_isin)
empty_isin = df_universe['ISIN'].isna().sum()
if empty_isin:
logger.warning("Righe con ISIN mancante nel file universo: %d", int(empty_isin))
def validate_returns_frame(df_returns: pd.DataFrame, threshold: float = 0.2):
if df_returns.empty:
logger.error("Nessun dato di rendimento recuperato: final_df vuoto.")
sys.exit(1)
na_ratio = df_returns.isna().mean()
high_na = na_ratio[na_ratio > threshold]
if not high_na.empty:
logger.warning("Colonne con >%.0f%% di NaN prima del fill: %s",
threshold * 100,
", ".join([f"{c} ({v:.0%})" for c, v in high_na.items()]))
# ---------------------------------
# Utility per R^2 sull’equity line
@@ -310,28 +336,27 @@ def portfolio_path_metrics(period_df: pd.DataFrame,
"Hmin_100m_5Y": hmin_5y_months
}
def load_db_config():
"""Recupera i parametri di connessione dal set di variabili d'ambiente."""
required_keys = ["DB_USERNAME", "DB_PASSWORD", "DB_HOST", "DB_NAME"]
missing = [k for k in required_keys if not os.getenv(k)]
if missing:
raise RuntimeError(f"Variabili d'ambiente mancanti per il DB: {', '.join(missing)}")
# --- Lettura parametri dal file connection.txt ---
params = {}
with open("connection.txt", "r") as f:
for line in f:
line = line.strip()
if line and not line.startswith("#"):
key, value = line.split("=", 1)
params[key.strip()] = value.strip()
return {
"username": os.getenv("DB_USERNAME"),
"password": os.getenv("DB_PASSWORD"),
"host": os.getenv("DB_HOST"),
"port": os.getenv("DB_PORT", "1433"),
"database": os.getenv("DB_NAME"),
}
username = params.get("username")
password = params.get("password")
host = params.get("host")
port = params.get("port", "1433")
database = params.get("database")
db_cfg = load_db_config()
connection_string = (
f"mssql+pyodbc://{db_cfg['username']}:{db_cfg['password']}@{db_cfg['host']}:{db_cfg['port']}/{db_cfg['database']}"
f"mssql+pyodbc://{username}:{password}@{host}:{port}/{database}"
"?driver=ODBC+Driver+17+for+SQL+Server"
)
print("Connection string configurata da variabili d'ambiente.")
print("Connection string letta correttamente")
# =========================
# CONNESSIONE AL DB
@@ -357,85 +382,7 @@ df = pd.read_excel(
usecols=['ISIN', 'Nome', 'Categoria', 'Asset Class', 'PesoMax', 'PesoFisso', 'Codice Titolo'],
dtype={'Codice Titolo': str}
)
# =========================
# VALIDAZIONE DATI RENDIMENTI
# =========================
def _gap_ranges_missing(series: pd.Series, all_dates: pd.DatetimeIndex, max_entries: int = 3):
"""Restituisce fino a max_entries intervalli di date mancanti (start, end, len)."""
missing_idx = series[series.isna()].index
if missing_idx.empty:
return []
positions = [all_dates.get_loc(ts) for ts in missing_idx if ts in all_dates]
if not positions:
return []
ranges = []
start_pos = positions[0]
end_pos = positions[0]
for pos in positions[1:]:
if pos == end_pos + 1:
end_pos = pos
else:
ranges.append((all_dates[start_pos], all_dates[end_pos], end_pos - start_pos + 1))
start_pos = end_pos = pos
ranges.append((all_dates[start_pos], all_dates[end_pos], end_pos - start_pos + 1))
return ranges[:max_entries]
def preprocess_returns(temp_df: pd.DataFrame, isin: str, all_dates: pd.DatetimeIndex,
gap_ffill_limit: int = GAP_FFILL_LIMIT_DAYS) -> pd.Series:
"""Pulizia/validazione serie rendimenti (tipi, duplicati, buchi, niente fillna(0))."""
required_cols = {"Px_Date", "RendimentoGiornaliero"}
missing_cols = required_cols.difference(temp_df.columns)
if missing_cols:
print(f"[{isin}] Colonne mancanti {missing_cols}, asset ignorato.")
return pd.Series(dtype=float)
df_local = temp_df.copy()
df_local["Px_Date"] = pd.to_datetime(df_local["Px_Date"], errors="coerce").dt.normalize()
df_local["RendimentoGiornaliero"] = pd.to_numeric(df_local["RendimentoGiornaliero"], errors="coerce")
before_rows = len(df_local)
df_local = df_local.dropna(subset=["Px_Date", "RendimentoGiornaliero"])
dropped_na = before_rows - len(df_local)
dup_count = df_local.duplicated(subset=["Px_Date"]).sum()
if dup_count > 0:
print(f"[{isin}] Drop duplicati su Px_Date: {dup_count}")
df_local = df_local.drop_duplicates(subset=["Px_Date"], keep="last").sort_values("Px_Date")
if df_local.empty:
print(f"[{isin}] Nessuna riga valida dopo cleaning, asset ignorato.")
return pd.Series(dtype=float)
df_local["RendimentoGiornaliero"] = df_local["RendimentoGiornaliero"] / 100.0
series = df_local.set_index("Px_Date")["RendimentoGiornaliero"].reindex(all_dates)
missing_before_fill = int(series.isna().sum())
if missing_before_fill > 0:
gaps = _gap_ranges_missing(series, all_dates, max_entries=3)
if gaps:
gaps_str = "; ".join([f"{g[0].date()}->{g[1].date()} ({g[2]} gg)" for g in gaps])
print(f"[{isin}] Date mancanti prima del fill (prime): {gaps_str}")
series_ffill = series.ffill(limit=gap_ffill_limit)
first_valid = series_ffill.first_valid_index()
last_valid = series_ffill.last_valid_index()
if first_valid is None or last_valid is None:
print(f"[{isin}] Serie vuota dopo forward-fill, asset ignorato.")
return pd.Series(dtype=float)
series_ffill = series_ffill.loc[first_valid:last_valid]
residual_missing = int(series_ffill.isna().sum())
if residual_missing > 0:
print(f"[{isin}] {residual_missing} valori mancanti non coperti dal forward-fill (limite {gap_ffill_limit}), righe scartate.")
series_ffill = series_ffill.dropna()
coverage_days = series_ffill.shape[0]
if dropped_na > 0 or missing_before_fill > 0:
print(f"[{isin}] Righe totali: {before_rows}, drop NA: {dropped_na}, copertura finale: {coverage_days} giorni.")
return series_ffill
validate_universe(df)
# =========================
# SERIE STORICHE RENDIMENTI
@@ -455,23 +402,18 @@ for isin in df['ISIN'].unique():
if temp_df.empty:
print(f"Nessun dato recuperato per {isin}, skipping...")
continue
clean_series = preprocess_returns(temp_df, isin, all_dates, gap_ffill_limit=GAP_FFILL_LIMIT_DAYS)
if clean_series.empty:
print(f"Nessun dato valido per {isin} dopo la validazione, asset ignorato.")
continue
final_df[isin] = clean_series.reindex(all_dates)
temp_df['Px_Date'] = pd.to_datetime(temp_df['Px_Date'], format='%Y-%m-%d', errors='coerce').dt.normalize()
temp_df = temp_df.dropna(subset=['Px_Date'])
temp_df.set_index('Px_Date', inplace=True)
temp_df['RendimentoGiornaliero'] = temp_df['RendimentoGiornaliero'] / 100
final_df[isin] = temp_df['RendimentoGiornaliero'].reindex(all_dates)
isin_from_db.add(isin)
non_null = int(final_df[isin].count())
missing_left = int(final_df[isin].isna().sum())
print(f"Dati recuperati per {isin}: {non_null} righe valide, mancanti residui: {missing_left}.")
print(f"Dati recuperati per {isin}: {final_df[isin].count()} righe di dati non-null prelevate.")
except SQLAlchemyError as e:
print(f"Errore durante l'esecuzione della stored procedure per {isin}:", e)
final_df = final_df.loc[:, final_df.notna().any()] # elimina asset senza dati utili
if final_df.shape[1] == 0:
print("Nessun ISIN valido dopo la validazione dei rendimenti, uscita.")
sys.exit(1)
final_df = final_df.dropna(how='all')
validate_returns_frame(final_df)
final_df.fillna(0, inplace=True)
# -------- H_min sempre su 5 anni (21 gg = 1 mese) --------
five_year_df = final_df.loc[end_date - pd.DateOffset(years=5): end_date]
@@ -566,7 +508,12 @@ for (years, target_vol), name in volatility_targets.items():
ef.add_constraint(lambda w, idxs=idxs, maxw=maxw: sum(w[i] for i in idxs) <= maxw)
# Vincoli per Asset Class
for ac, maxw in asset_class_limits_cfg.items():
asset_class_limits = {
'Azionari': 0.75, 'Obbligazionari': 0.75,
'Metalli Preziosi': 0.20, 'Materie Prime': 0.05,
'Immobiliare': 0.05, 'Criptovalute': 0.05, 'Monetari': 0.1
}
for ac, maxw in asset_class_limits.items():
isin_list = df[df['Asset Class'] == ac]['ISIN'].tolist()
idxs = [period_df.columns.get_loc(isin) for isin in isin_list if isin in period_df.columns]
if idxs:
@@ -607,16 +554,13 @@ for (years, target_vol), name in volatility_targets.items():
results_rows.append(row)
results_full_df = pd.DataFrame(results_rows, columns=template_cols)
if results_full_df.empty:
output_df = template_df.iloc[0:0].copy()
else:
output_df = results_full_df.reindex(columns=template_cols)
output_df = pd.concat([template_df.iloc[0:0], results_full_df], ignore_index=True)
output_file_path = excel_path(f'PTFOPT{name}.xlsx')
output_df.to_excel(output_file_path, index=False)
print(f"File {output_file_path} saved successfully.")
# --- Pie chart asset allocation (se ci sono pesi > 0) ---
asset_allocations = {asset: 0 for asset in asset_class_limits_cfg}
asset_allocations = {asset: 0 for asset in asset_class_limits}
for isin, weight in weights.items():
r_sel = df.loc[df['ISIN'] == isin]
if r_sel.empty:
@@ -833,7 +777,12 @@ if cp is not None:
if idxs:
ef_h.add_constraint(lambda w, idxs=idxs, maxw=maxw: cp.sum(w[idxs]) <= maxw)
for ac, maxw in asset_class_limits_cfg.items():
asset_class_limits = {
'Azionari': 0.75, 'Obbligazionari': 0.75,
'Metalli Preziosi': 0.20, 'Materie Prime': 0.05,
'Immobiliare': 0.05, 'Criptovalute': 0.05, 'Monetari': 0.1
}
for ac, maxw in asset_class_limits.items():
isin_list = df[df['Asset Class'] == ac]['ISIN'].tolist()
idxs = [period_df_p.columns.get_loc(isin) for isin in isin_list if isin in period_df_p.columns]
if idxs: