FIRE 75.03 PAD Equity Line

Assolutamente. È un’ottima idea formalizzare il piano. Avere una roadmap chiara ci aiuterà a implementare la feature in modo strutturato, modulare e a ridurre i rischi.

Ecco un piano d’azione dettagliato, suddiviso in tre fasi principali.

Piano d’Azione: Implementazione del Grafico Equity Line

Obiettivo: Integrare un grafico dinamico dell’equity line come seconda tab nell’area centrale di visualizzazione, aggiornato al termine di ogni backtest.

Fase 1: Fondamenta dei Dati (Logica di Backend)

In questa fase, calcoleremo i dati necessari per l’equity line e li renderemo disponibili all’interfaccia utente.

Task 1.1: Calcolo dell’Equity Curve
- File da modificare: fire/synapses/backtest/backtest_worker.py
- Logica da aggiungere: All’interno del metodo run(), dopo aver calcolato le statistiche, implementeremo un nuovo metodo privato (es. _calculate_equity_curve).
  1. Questo metodo prenderà in input il DataFrame dei trade (trades_df) e un capitale iniziale (es. 10000).
  2. Calcolerà una colonna di profitto cumulativo per ogni trade.
  3. Creerà una serie temporale (pd.Series) dove l’indice è la data di chiusura di ogni operazione (exit_date) e il valore è il capitale iniziale più il profitto cumulativo fino a quel momento.
  4. Questa serie sarà la nostra “equity curve”.
- Azione Concreta: Aggiungeremo la nuova serie equity_curve al dizionario results che viene emesso dal segnale finished.
Task 1.2: Propagazione dei Dati all’Interfaccia
- File da modificare: fire/synapses/backtest/backtest_tab_widget.py
- Logica da aggiungere: Modificheremo lo slot on_backtest_finished(self, results: dict).
- Azione Concreta: Estrarremo la equity_curve dal dizionario results e la aggiungeremo al dizionario plot_args che viene emesso dal segnale plot_data_requested. In questo modo, un singolo segnale trasporterà tutti i dati necessari per i grafici.

Risultato Fase 1: Al termine di un backtest, i dati grezzi dell’equity line saranno disponibili per l’interfaccia, pronti per essere visualizzati.

Fase 2: Componenti di Visualizzazione (Logica UI)

In questa fase, costruiremo i mattoni necessari per visualizzare il nuovo grafico.

Task 2.1: Scelta della Libreria Grafica (Decisione Chiave)
- Dobbiamo scegliere la tecnologia per il nuovo grafico.
- Opzione A (Consigliata): PyQtGraph. Estremamente veloce, leggera e progettata per un’integrazione nativa e performante con PySide6. Ideale per grafici di dati semplici come una linea. Richiede di aggiungere pyqtgraph alle dipendenze.
- Opzione B (Alternativa): Matplotlib. Potente e conosciuta, ma l’integrazione con Qt può essere più lenta e complessa.
- Azione Concreta: Concordiamo sull’uso di PyQtGraph per la sua efficienza.
Task 2.2: Creazione del Widget per il Grafico Equity
- Nuovo File: fire/ui_components/charts/equity_chart_widget.py
- Logica da implementare: Creeremo una nuova classe EquityChartWidget(QWidget).
  1. Al suo interno, conterrà un’istanza di pyqtgraph.PlotWidget.
  2. Esporrà un metodo pubblico plot_equity(self, equity_series: pd.Series) che prenderà i dati e li traccerà sul grafico.
  3. Includerà anche un metodo clear_chart() per pulire il grafico.
Task 2.3: Potenziamento del Contenitore Centrale
- File da modificare: fire/ui_components/charts/charting_tabs_widget.py
- Logica da aggiungere: Questo widget deve trasformarsi da semplice contenitore a un vero gestore di tab.
  1. Cambieremo la sua classe base da QWidget a QTabWidget.
  2. Nel suo __init__, creerà istanze sia del LightweightChartWidget esistente sia del nuovo EquityChartWidget.
  3. Aggiungerà questi due widget come tab separate (“Grafico Prezzi” e “Equity Curve”).
  4. Il metodo pubblico plot_data verrà sostituito da un metodo più generico, update_charts(self, data_dict: dict), che funzionerà da “router”: controllerà le chiavi nel dizionario ricevuto e passerà i dati corretti al widget figlio appropriato.

Risultato Fase 2: Avremo tutti i componenti UI pronti: un widget per il grafico e un contenitore a tab in grado di gestirlo.

Fase 3: Integrazione e Connessione Finale

Quest’ultima fase consiste nel collegare il backend e il frontend.

Task 3.1: Aggiornamento della Connessione Principale
- File da modificare: fire/main_window.py
- Logica da modificare: Aggiorneremo la connessione nel metodo _connect_signals_slots.
- Azione Concreta: La riga self.controls_panel.plot_data_requested.connect(self.charting_panel.plot_data) diventerà self.controls_panel.plot_data_requested.connect(self.charting_panel.update_charts).

Risultato Fase 3: Il flusso di dati è completo. Un backtest terminato attiverà un segnale che, attraverso la MainWindow, arriverà al ChartingTabsWidget, il quale aggiornerà entrambi i grafici con i dati pertinenti.

Riepilogo Tabellare

Fase	Task	File Coinvolti	Azione Principale
1. Dati	Calcolo Equity	`backtest_worker.py`	Aggiungere il calcolo della curva di equity.
	Propagazione Dati	`backtest_tab_widget.py`	Aggiungere i dati dell’equity al segnale `plot_data_requested`.
2. UI	Scelta Libreria	(Decisione)	Scegliere `PyQtGraph`.
	Widget Grafico	`equity_chart_widget.py` (Nuovo)	Creare un widget per visualizzare il grafico.
	Gestore Tab	`charting_tabs_widget.py`	Trasformarlo in un `QTabWidget` con due tab.
3. Integrazione	Connessione	`main_window.py`	Aggiornare il segnale per chiamare il nuovo metodo “router”.

Prossimo Passo

Se questo piano dettagliato ti convince, il nostro prossimo passo concreto sarà il Task 1.1: modificare il BacktestWorker per calcolare e restituire l’equity curve.

Quartz 4

Explorer