Quartz 4

POC: Charting Finanziario Nativo con Qt Charts

5 min read

python .\scripts\poc\test_pyqtchart_widget.py

Contesto

Le soluzioni di charting precedentemente validate (Matplotlib, Plotly) si basano sull’integrazione di librerie di terze parti all’interno di un’applicazione Qt, ognuna con i propri compromessi (interattività limitata per Matplotlib, overhead di risorse per Plotly). Una terza via, potenzialmente superiore in termini di performance e integrazione, è l’utilizzo del modulo Qt Charts, fornito direttamente dal framework Qt.

Questo POC è stato creato per rispondere alla domanda: “È fattibile e vantaggioso costruire i nostri grafici finanziari utilizzando esclusivamente i componenti nativi di Qt?”

Decisione

È stato sviluppato un widget di charting sperimentale, PyQtChartWidget, che costruisce un grafico a candele utilizzando le classi native del modulo PySide6.QtCharts.

L’approccio implementato è radicalmente diverso da quelli precedenti:

  • Nessuna Dipendenza Esterna: Lo script non importa matplotlib o plotly. L’intero grafico è costruito e renderizzato da Qt.
  • Composizione Manuale: Il grafico viene assemblato “a mano”, pezzo per pezzo, utilizzando le classi fornite da Qt:
    • QChart e QChartView per la struttura di base.
    • QCandlestickSeries per contenere i dati delle candele.
    • QCandlestickSet per rappresentare ogni singola candela.
    • QDateTimeAxis e QValueAxis per gli assi.
  • Conversione dei Dati: È stata implementata la logica per convertire i dati da un DataFrame pandas al formato richiesto da Qt Charts (inclusa la conversione dei timestamp in millisecondi).
  • Stile Nativo: Lo stile (es. il tema scuro) viene applicato utilizzando i metodi e le classi di Qt (QColor, setBackgroundBrush).

Conseguenze

Positive

  • Performance Potenzialmente Superiori: Essendo una soluzione nativa, Qt Charts può sfruttare l’accelerazione hardware in modo più efficiente, risultando potenzialmente più veloce e fluido, specialmente con aggiornamenti di dati in tempo reale e interazioni dell’utente.
  • Integrazione Perfetta: Il widget si integra in modo impeccabile con il resto dell’applicazione Qt, sia in termini di stile che di comportamento.
  • Zero Dipendenze di Plotting Aggiuntive: Questo approccio riduce la complessità dell’ambiente e il numero di dipendenze da gestire.
  • Interattività di Base Inclusa: I grafici Qt Charts offrono funzionalità di base come zoom e pan out-of-the-box.

Negative / Limitazioni

  • API Verbosa e Complessa: La costruzione del grafico è molto più laboriosa e richiede più righe di codice rispetto a librerie di alto livello come mplfinance o plotly.
  • Mancanza di Funzionalità Finanziarie Avanzate: Funzionalità come il plotting automatico del volume, l’aggiunta di indicatori tecnici (es. medie mobili, RSI) o tipi di grafico non standard (es. Kagi) non sono disponibili nativamente e richiederebbero un’implementazione custom significativa.
  • Sforzo di Sviluppo Maggiore: Aggiungere nuove funzionalità al grafico (es. un secondo asse Y, grafici a barre per il volume) è un compito non banale.
  • Stato Sperimentale: Come indicato nel codice, questo approccio è considerato sperimentale. La maturità e la flessibilità potrebbero non essere paragonabili a quelle di librerie dedicate e consolidate come Matplotlib.

Q & A

1. Per eseguire questo test c’è bisogno di due file?

Sì, in pratica sì. Ecco perché:

  • File 1 (pyqt_chart_widget.py): Questo file è come il progetto di un componente. Definisce una classe, PyQtChartWidget, che è un “mattoncino Lego” riutilizzabile. Non fa nulla da solo. È solo una definizione, una ricetta.

  • File 2 (test_pyqtchart_widget.py): Questo file è l’operaio che costruisce qualcosa usando quel progetto. Fa le seguenti cose:

    1. Crea un’applicazione e una finestra (l’impalcatura).
    2. Usa il progetto (from pyqt_chart_widget import PyQtChartWidget) per costruire un’istanza reale del componente.
    3. Mette il componente nella finestra.
    4. Gli dà dei dati di esempio da visualizzare.
    5. Accende l’applicazione per mostrare il risultato.

Potresti mettere tutto in un unico file? Assolutamente sì. Potresti prendere il codice di test_pyqtchart_widget.py e incollarlo in fondo a pyqt_chart_widget.py. Funzionerebbe lo stesso.

Perché allora si usano due file? È una buona pratica di programmazione che separa le responsabilità:

  • Il file del widget (pyqt_chart_widget.py) è pulito e riutilizzabile. Puoi importarlo in qualsiasi parte della tua applicazione principale FIRE senza portarti dietro il codice di test.
  • Il file di test (test_pyqtchart_widget.py) serve solo per isolare e testare quel singolo componente, senza “sporcare” il codice del componente stesso.

Quindi, anche se tecnicamente potresti unirli, la separazione in due file è un approccio molto più professionale e manutenibile.

2. Serve per testare le librerie per la rappresentazione di grafici utilizzando le librerie di Qt?

Esattamente. Hai centrato perfettamente lo scopo di questo POC.

Il suo obiettivo è validare la fattibilità e i compromessi dell’uso del modulo Qt Charts, che è il sistema di charting nativo e ufficiale fornito dal framework Qt (e quindi da PySide6).

Pensa alle tre opzioni che hai esplorato come tre modi diversi di costruire un’auto:

  1. Approccio Matplotlib (mpl_chart_widget.py):

    • Analogia: Prendere un telaio di un’auto (il QWidget di Qt) e montarci sopra un motore eccellente ma di un’altra marca (il grafico Matplotlib).
    • Pro: Il motore è affidabile, conosciuto e fa bene il suo lavoro.
    • Contro: L’integrazione richiede un “adattatore” (FigureCanvasQTAgg), e il motore non è stato progettato nativamente per quel telaio (l’interattività è difficile).

  2. Approccio Plotly (plotly_chart_widget.py):

    • Analogia: Invece di un motore, monti un intero simulatore di guida (il QWebEngineView) sul sedile del passeggero e lo usi per mostrare un’auto virtuale (il grafico Plotly).
    • Pro: L’auto virtuale è bellissima, super interattiva e moderna.
    • Contro: È pesante, consuma molte risorse (memoria/CPU) e farla interagire con i comandi reali dell’auto è complesso.

  3. Approccio Qt Charts (pyqt_chart_widget.py) - QUELLO CHE STAI TESTANDO ORA:

    • Analogia: Costruire l’auto usando solo pezzi ufficiali forniti dalla casa madre (Qt). Il motore (QChart), la carrozzeria (QChartView), le ruote (QAxis) sono tutti progettati per funzionare insieme.
    • Pro: Integrazione perfetta, prestazioni potenzialmente massime, nessuna dipendenza esterna.
    • Contro: Devi montare ogni singolo bullone a mano. L’API è più complessa e “di basso livello”, e mancano le funzionalità specialistiche “già pronte” che offrono le altre soluzioni.

In conclusione, questo POC serve a rispondere alla domanda: “Vale la pena lo sforzo extra di usare la soluzione nativa di Qt in cambio di potenziali vantaggi in termini di performance e integrazione, oppure le altre soluzioni sono ‘abbastanza buone’ e più facili da usare?”

Graph View