fixed wekly report

Author: leoBitto

run_weekly_report.py

@@ -1,23 +1,23 @@
-# run_weekly_report.py - Versione Semplificata
+# run_weekly_report.py - Versione Finale
 """
-Entry Point: Report Settimanale Portfolio (VERSIONE SEMPLIFICATA)
-================================================================
-
-Workflow semplice e diretto:
-1. Genera segnali da tutte le strategie disponibili
-2. Applica risk management per validare/raffinare i segnali  
-3. Apre Google Sheet esistente nel drive
-4. Pulisce e scrive N+1 fogli:
-   - 1 foglio per strategia con segnali validati
-   - 1 foglio con snapshot portfolio della settimana
-5. Fine!
-
-Niente classi complesse, solo funzioni dirette.
+Entry Point: Report Settimanale Portfolio
+=========================================
+
+Workflow semplice e automatico:
+1. Scopre automaticamente tutte le strategie dal modulo strategies
+2. Genera segnali per ogni strategia (parametri da config)
+3. Apre Google Sheet WEEKLY_REPORTS_SHEET_ID
+4. Cancella tutti i fogli esistenti
+5. Crea N fogli strategia + 1 foglio portfolio snapshots (lun-ven)
+6. Fine!
+
+Eseguito ogni venerdì.
 """
 
 import logging
 import os
 import sys
+import inspect
 from datetime import datetime, timedelta
 import pandas as pd
 
@@ -36,66 +36,69 @@
 
 
 def main():
-    """Entry point per generazione report settimanale semplificato."""
+    """Entry point per generazione report settimanale."""
     start_time = datetime.now()
     today = start_time.strftime("%Y-%m-%d")
 
     logger.info("=" * 60)
-    logger.info("🚀 AVVIO REPORT SETTIMANALE SEMPLIFICATO")
+    logger.info("🚀 AVVIO REPORT SETTIMANALE")
     logger.info("=" * 60)
+    logger.info(f"Data: {today}")
 
     try:
-        # Import dopo logging setup
         from scripts import database, portfolio, strategies, risk_manager, google_services
         from scripts import config
 
-        # 1. CARICA PORTFOLIO
+        # 1. SCOPRI STRATEGIE AUTOMATICAMENTE
+        strategy_functions = _discover_strategy_functions()
+        logger.info(f"🎯 Strategie scoperte: {list(strategy_functions.keys())}")
+        
+        # 2. CARICA PORTFOLIO DEMO
         logger.info("📊 Caricamento portfolio 'demo'...")
         pf = portfolio.Portfolio("demo", today)
-        logger.info(f"Portfolio caricato: valore={pf.get_total_value():,.2f}€, cash={pf.get_cash_balance():,.2f}€")
-        
-        # 2. CARICA DATI UNIVERSE (ultima settimana)
-        week_ago = (datetime.now() - timedelta(days=7)).strftime("%Y-%m-%d")
-        logger.info(f"📈 Caricamento dati universe dal {week_ago} al {today}...")
-        df = database.get_universe_data(start_date=week_ago, end_date=today)
-        logger.info(f"Dati caricati: {len(df)} righe, {df['ticker'].nunique()} ticker")
+        logger.info(f"Portfolio: valore=€{pf.get_total_value():,.2f}, cash=€{pf.get_cash_balance():,.2f}")
 
-        # 3. GENERA SEGNALI PER OGNI STRATEGIA
-        strategies_list = [
-            ("Moving_Average", strategies.moving_average_crossover),
-            ("RSI_Strategy", strategies.rsi_strategy), 
-            ("Breakout_Strategy", strategies.breakout_strategy)
-        ]
+        # 3. CARICA DATI UNIVERSE (ultimi 60 giorni per sicurezza)
+        days_ago = (datetime.now() - timedelta(days=60)).strftime("%Y-%m-%d")
+        logger.info(f"📈 Caricamento dati universe dal {days_ago}...")
+        df = database.get_universe_data(start_date=days_ago, end_date=today)
+        logger.info(f"Dati: {len(df)} righe, {df['ticker'].nunique()} ticker")
 
-        signals_data = {}
-        for strategy_name, strategy_fn in strategies_list:
+        # 4. GENERA SEGNALI PER OGNI STRATEGIA
+        all_signals = {}
+        for strategy_name, strategy_fn in strategy_functions.items():
             logger.info(f"🎯 Generazione segnali: {strategy_name}")
 
-            # Genera e raffina segnali
-            signals = risk_manager.generate_signals(strategy_fn, df, today, pf)
-            
-            # Converti in DataFrame per Google Sheets
-            signals_df = _convert_signals_to_dataframe(signals, strategy_name)
-            signals_data[strategy_name] = signals_df
-            
-            buy_count = len(signals.get("BUY", {}))
-            sell_count = len(signals.get("SELL", {})) 
-            hold_count = len(signals.get("HOLD", {}))
-            logger.info(f"Segnali {strategy_name}: BUY={buy_count}, SELL={sell_count}, HOLD={hold_count}")
+            try:
+                signals = risk_manager.generate_signals(strategy_fn, df, today, pf)
+                signals_df = _convert_signals_to_dataframe(signals, strategy_name)
+                all_signals[strategy_name] = signals_df
+                
+                buy_count = len(signals.get("BUY", {}))
+                sell_count = len(signals.get("SELL", {}))
+                hold_count = len(signals.get("HOLD", {}))
+                logger.info(f"Segnali {strategy_name}: BUY={buy_count}, SELL={sell_count}, HOLD={hold_count}")
+                
+            except Exception as e:
+                logger.error(f"Errore strategia {strategy_name}: {e}")
+                # Crea DataFrame vuoto per non rompere il report
+                all_signals[strategy_name] = pd.DataFrame()
 
-        # 4. GENERA SNAPSHOT PORTFOLIO SETTIMANALE
-        logger.info("📸 Generazione snapshot portfolio settimanale...")
-        portfolio_df = _generate_portfolio_snapshots(pf, week_ago, today)
+        # 5. GENERA PORTFOLIO SNAPSHOTS (lun-ven)
+        logger.info("📸 Caricamento portfolio snapshots settimana...")
+        portfolio_df = _get_portfolio_snapshots_week(portfolio_name, today)
 
-        # 5. SCRIVI GOOGLE SHEETS
-        logger.info("📝 Scrittura Google Sheets...")
-        sheet_url = _write_to_google_sheets(signals_data, portfolio_df, today)
+        # 6. SCRIVI GOOGLE SHEET
+        logger.info("📝 Scrittura Google Sheet...")
+        sheet_url = _write_to_google_sheet(all_signals, portfolio_df)
 
         # SUCCESS
         duration = datetime.now() - start_time
         logger.info("=" * 60)
         logger.info("✅ REPORT GENERATO CON SUCCESSO!")
         logger.info("=" * 60)
+        logger.info(f"Strategie processate: {len(all_signals)}")
+        logger.info(f"Portfolio snapshots: {len(portfolio_df)} giorni")
         logger.info(f"Durata: {duration.total_seconds():.1f} secondi")
         logger.info(f"Google Sheet: {sheet_url}")
         logger.info("📊 REPORT PRONTO PER REVIEW!")
@@ -106,6 +109,25 @@ def main():
         raise
 
 
+def _discover_strategy_functions():
+    """Scopre automaticamente tutte le funzioni strategia dal modulo strategies."""
+    from scripts import strategies
+    
+    strategy_functions = {}
+    
+    # Scandisce tutti gli attributi del modulo strategies
+    for name in dir(strategies):
+        obj = getattr(strategies, name)
+        
+        # Controlla se è una funzione (non classe, non built-in, non privata)
+        if (inspect.isfunction(obj) and 
+            not name.startswith('_') and 
+            obj.__module__ == strategies.__name__):
+            strategy_functions[name] = obj
+    
+    return strategy_functions
+
+
 def _convert_signals_to_dataframe(signals: dict, strategy_name: str) -> pd.DataFrame:
     """Converte dict segnali in DataFrame per Google Sheets."""
     rows = []
@@ -114,21 +136,21 @@ def _convert_signals_to_dataframe(signals: dict, strategy_name: str) -> pd.DataF
     for ticker, data in signals.get("BUY", {}).items():
         rows.append({
             "Ticker": ticker,
-            "Signal": "BUY", 
+            "Signal": "BUY",
             "Strategy": strategy_name,
             "Size": data.get("size", 0),
             "Price": data.get("price", 0),
             "Stop_Loss": data.get("stop", 0),
             "Risk_Amount": data.get("risk", 0),
-            "Notes": f"Size: {data.get('size', 0)} shares"
+            "Notes": f"Size: {data.get('size', 0)} shares at €{data.get('price', 0):.2f}"
         })
 
-    # SELL signals  
+    # SELL signals
     for ticker, data in signals.get("SELL", {}).items():
         rows.append({
             "Ticker": ticker,
             "Signal": "SELL",
-            "Strategy": strategy_name, 
+            "Strategy": strategy_name,
             "Size": data.get("quantity", 0),
             "Price": data.get("price", 0),
             "Stop_Loss": "",
@@ -149,77 +171,103 @@ def _convert_signals_to_dataframe(signals: dict, strategy_name: str) -> pd.DataF
             "Notes": data.get("reason", "Keep position")
         })
 
+    if not rows:
+        # Se non ci sono segnali, crea DataFrame con intestazioni vuote
+        return pd.DataFrame(columns=["Ticker", "Signal", "Strategy", "Size", "Price", 
+                                   "Stop_Loss", "Risk_Amount", "Notes"])
+    
     return pd.DataFrame(rows)
 
 
-def _generate_portfolio_snapshots(pf, start_date: str, end_date: str) -> pd.DataFrame:
-    """Genera snapshots portfolio per la settimana."""
+def _get_portfolio_snapshots_week(portfolio_name: str, today_str: str) -> pd.DataFrame:
+    """Recupera snapshots portfolio da lunedì a venerdì (today-5 giorni lavorativi)."""
     from scripts import database
 
-    # Query snapshot della settimana
+    # Calcola lunedì della settimana corrente (oggi è venerdì)
+    today = datetime.strptime(today_str, "%Y-%m-%d")
+    monday = today - timedelta(days=4)  # Venerdì - 4 giorni = Lunedì
+    
+    start_date = monday.strftime("%Y-%m-%d")
+    end_date = today_str
+    
+    logger.info(f"Caricamento snapshots da {start_date} a {end_date}")
+    
     query = """
         SELECT date, total_value, cash_balance, positions_count,
-               total_return_pct, max_drawdown_pct, volatility_pct, sharpe_ratio
-        FROM portfolio_snapshots  
+               total_return_pct, max_drawdown_pct, volatility_pct, sharpe_ratio, win_rate_pct
+        FROM portfolio_snapshots
         WHERE portfolio_name = %s AND date BETWEEN %s AND %s
         ORDER BY date
     """
 
-    rows, columns = database.execute_query(query, (pf.name, start_date, end_date))
-    df = pd.DataFrame(rows, columns=columns)
-    
-    # Converti date in stringhe per Google Sheets
-    if not df.empty and 'date' in df.columns:
-        df['date'] = df['date'].astype(str)
-    
-    return df
+    try:
+        rows, columns = database.execute_query(query, (portfolio_name, start_date, end_date))
+        df = pd.DataFrame(rows, columns=columns)
+        
+        # Converti date in stringhe per Google Sheets
+        if not df.empty and 'date' in df.columns:
+            df['date'] = df['date'].astype(str)
+        
+        return df
+        
+    except Exception as e:
+        logger.error(f"Errore caricamento snapshots: {e}")
+        # Ritorna DataFrame vuoto con colonne corrette
+        return pd.DataFrame(columns=["date", "total_value", "cash_balance", "positions_count",
+                                   "total_return_pct", "max_drawdown_pct", "volatility_pct", 
+                                   "sharpe_ratio", "win_rate_pct"])
 
 
-def _write_to_google_sheets(signals_data: dict, portfolio_df: pd.DataFrame, date: str) -> str:
-    """Scrive tutti i dati su Google Sheets e ritorna URL."""
+def _write_to_google_sheet(all_signals: dict, portfolio_df: pd.DataFrame) -> str:
+    """Scrive tutti i dati nel Google Sheet configurato."""
     from scripts import google_services, config
 
+    logger.info("Apertura Google Sheet...")
     client = google_services.get_gsheet_client()
 
-    # Apri/crea spreadsheet per la settimana
-    sheet_name = f"Weekly_Report_{date}"
+    # Apri sheet configurato
+    spreadsheet = client.open_by_key(config.WEEKLY_REPORTS_SHEET_ID)
+    logger.info(f"Aperto sheet: {spreadsheet.title}")
 
-    try:
-        # Prova ad aprire sheet esistente nella cartella
-        # (questo richiede di implementare una funzione per cercare nella cartella)
-        # Per ora creiamo sempre nuovo sheet
-        spreadsheet = client.create(sheet_name)
-        
-        # Sposta nella cartella corretta se definita
-        if hasattr(config, 'WEEKLY_REPORTS_FOLDER_ID'):
-            # Codice per spostare il file nella cartella...
-            pass
-            
-    except Exception as e:
-        logger.warning(f"Creazione nuovo sheet fallita: {e}")
-        # Fallback: usa sheet di test
-        spreadsheet = client.open_by_key(config.TEST_SHEET_ID)
-    
-    # Pulisci tutti i worksheet esistenti (tranne il primo)
+    # CANCELLA TUTTI I FOGLI ESISTENTI
     worksheets = spreadsheet.worksheets()
-    for ws in worksheets[1:]:  # Mantieni il primo
-        spreadsheet.del_worksheet(ws)
+    for ws in worksheets:
+        try:
+            spreadsheet.del_worksheet(ws)
+            logger.info(f"Cancellato foglio: {ws.title}")
+        except Exception as e:
+            logger.warning(f"Errore cancellando foglio {ws.title}: {e}")
 
-    # Rinomina il primo worksheet
-    main_ws = worksheets[0]
-    main_ws.update_title("Portfolio_Snapshot")
+    # CREA FOGLIO PORTFOLIO SNAPSHOTS
+    logger.info("Creazione foglio Portfolio_Snapshots...")
+    portfolio_ws = spreadsheet.add_worksheet(title="Portfolio_Snapshots", rows=50, cols=15)
 
-    # Scrivi snapshot portfolio
     if not portfolio_df.empty:
-        main_ws.update([portfolio_df.columns.tolist()] + portfolio_df.values.tolist())
+        # Scrivi intestazioni + dati
+        data_to_write = [portfolio_df.columns.tolist()] + portfolio_df.values.tolist()
+        portfolio_ws.update(data_to_write)
+        logger.info(f"Scritti {len(portfolio_df)} snapshots portfolio")
+    else:
+        portfolio_ws.update([["Nessun dato disponibile"]])
+        logger.warning("Nessun snapshot portfolio disponibile")
 
-    # Crea worksheet per ogni strategia
-    for strategy_name, signals_df in signals_data.items():
+    # CREA FOGLIO PER OGNI STRATEGIA
+    for strategy_name, signals_df in all_signals.items():
+        logger.info(f"Creazione foglio: {strategy_name}")
+        
+        # Crea worksheet
         ws = spreadsheet.add_worksheet(title=strategy_name, rows=100, cols=10)
+        
         if not signals_df.empty:
-            ws.update([signals_df.columns.tolist()] + signals_df.values.tolist())
+            # Scrivi intestazioni + dati
+            data_to_write = [signals_df.columns.tolist()] + signals_df.values.tolist()
+            ws.update(data_to_write)
+            logger.info(f"Scritti {len(signals_df)} segnali per {strategy_name}")
+        else:
+            ws.update([["Nessun segnale generato"]])
+            logger.warning(f"Nessun segnale per strategia {strategy_name}")
 
-    logger.info(f"Google Sheet scritto: {spreadsheet.title}")
+    logger.info(f"✅ Google Sheet aggiornato: {len(all_signals)} strategie + 1 portfolio")
     return spreadsheet.url
 
 

scripts/config.py

@@ -28,7 +28,7 @@
 # Google Sheets IDs
 UNIVERSE_SPREADSHEET_ID = "1Uh3S3YCyvupZ5yZh2uDi0XYGaZIkEkupxsYed6xRxgA"
 WEEKLY_REPORTS_FOLDER_ID = "1pGSxyPjc8rotTFZp-HA-Xrl7yZHjDWDh"
-TEST_SHEET_ID = "1fGTT6O197auwyHGnEBKwvHm3oZwwWz9r8Nm4hz76jKM"
+WEEKLY_REPORTS_SHEET_ID = "1fGTT6O197auwyHGnEBKwvHm3oZwwWz9r8Nm4hz76jKM"
 
 # Secret Manager secret names
 DB_SECRET_NAME = "db_info"