In questo tutorial, costruiamo un workflow completamente offline utilizzando Graphify e NetworkX per trasformare un'applicazione Python multi-modulo in un grafo della conoscenza. Iniziamo installando Graphify insieme alle librerie per l'analisi grafica e ai grafici necessari. Successivamente, generiamo un'applicazione di esempio con moduli per la configurazione, l'accesso, i servizi, l'API, la cache, il modello e la gestione del database. Estraiamo il grafo direttamente con strumenti locali, senza bisogno di chiavi API o di backend basati su grandi modelli linguistici. Carichiamo quindi il file generato di graph.json in NetworkX e analizziamo la struttura del codice utilizzando misure di centralità, rilevamento delle comunità ed esaminando i cammini più brevi tra i simboli principali. Alla fine, creiamo sia visualizzazioni statiche che interattive per capire la relazione tra moduli, classi, funzioni e oggetti del database all'interno del progetto.

Installazione di Graphify e NetworkX

Installiamo Graphify insieme alle librerie necessarie per lavorare con i grafici e le visualizzazioni.

Il seguente codice esegue l'installazione:

graphifyy[sql]: utilizzato per l'estrazione del grafo da linguaggi di programmazione e file SQL

pyvis: per le visualizzazioni interattive

networkx: per l’elaborazione su grafi

matplotlib: per le visualizzazioni statiche

Una volta installati i pacchetti, importiamo i moduli Python necessari. Per mantenere la pulizia dell'output, disabilitiamo alcuni avvisi.

Una volta completata l'installazione, possiamo procedere alla fase successiva, ovvero la creazione dell'applicazione di esempio.

Costruzione del Codebase di Esempio

Creiamo un set di file Python e uno schema SQL che rappresentano un'applicazione realistica. Questi includono:

config.py: contiene impostazioni centrali utilizzate in vari punti, funzione chiave per il concetto di "nodo dio"

database.py: gestisce le connessioni al database

models.py: definisce modelli come User e Session

cache.py: gestisce la limitazione di velocità

auth.py: funzioni di autenticazione

services.py: logica di servizi

api.py: endpoint API principali

main.py: esegue il codice principale

schema.sql: struttura iniziale del database

Una volta definiti i file ed esposte le relazioni di importazione, funzionalità e logica, salviamo il tutto nel directory "sample_app".

Ora abbiamo un insieme di file rappresentativo che Graphify potrà analizzare.

Estrazione del Grafo della Conoscenza

Utilizziamo Graphify per estrarre un grafo della struttura del nostro codice. Questo avviene in locale, senza bisogno di LLM o API esterne. L'output è un file JSON che verrà salvato in modo da poterlo successivamente importare in NetworkX.

Il processo include:

Esecuzione del comando graphify extract

Ricercare graph.json prodotto (in questo caso in una sottocartella)

Utilizzare una funzione caricatrice per NetworkX per trasformare i dati grezzi in un graph pronto per l'analisi

Questo passo ci consente di ottenere una rappresentazione chiara e strutturata della connessione tra moduli, classi e simboli all'interno dell’applicazione.

Analisi della Centralità e delle Comunità

Con il grafo pronto, conduciamo un’analisi strutturale per capire:

Quali moduli o file sono i "nodi dio"? (i nodi con la maggiore connettività)

Quali relazioni sono più frequenti tra i moduli?

Quali sono i gruppi di file o moduli che formano comunità?

Sviluppiamo il codice per:

Estrarre filetype, relation, e confidence da nodi ed archi

Calcolare centralità (grado e traente) e visualizzare i nodi di maggiore interesse

Individuare gruppi di nodi (community) usando algoritmi di Louvain e modularity

Questo ci aiuta a capire come si struttura l’applicazione: identifica moduli centrali, dipendenze problematiche e relazioni poco utilizzate, aiutando a progettare con maggiore chiarezza e modularità.

Visualizzazioni Statiche e Interattive

Con i dati estratti, possiamo creare rappresentazioni visuali che aiutino ad interpretare lo schema.

Visualizzazioni Statiche

Utilizziamo Matplotlib per generare grafici a forma di rete. Ogni nodo è rappresentato in base alla sua importanza (grado di centralità), mentre gli archi mostrano le relazioni (es. importazioni tra moduli). Posizioniamo etichette leggibili per facilitare le osservazioni.

Visualizzazioni Interattive

Utilizzando Pyvis, creiamo un grafico interattivo in formato HTML dove i lettori possono esplorare autonomamente le relazioni tra nodi, zoomare su moduli chiave o seguire cammini di interesse.

Le visualizzazioni interattive permettono:

Di esplorare cammini chiari con relazione gerarchica

Di identificare moduli non necessari o non collegati

Di visualizzare le comunità rilevanti

Di esaminare nodi chiave (i cosiddetti "nodi dio") e loro connessioni

Questi strumenti ci supportano nella comprensione di architetture complesse, rendendo trasparenti le interdipendenze all'interno del codice.

Conclusione e Approfondimenti

L'analisi con Graphify e NetworkX, unita a Pyvis per le visualizzazioni, si rivela potente per l'analisi di codebases di medie e grandi dimensioni. Essa non richiede API esterne e può essere eseguita localmente sul proprio hardware.

Le visualizzazioni permettono di:

Capire moduli centrali e identificare i "nodi dio" chiave

Esaminare comunità all'interno del progetto per migliorare la modularità

Scoprire architetture e potenziali problemi di dipendenza

Supportare il refactoring, riorientando il progetto verso un design più s