Integrazione Continua (CI)#
L'Integrazione Continua (CI) è un aspetto essenziale dello sviluppo software che prevede l'integrazione delle modifiche e il loro test automatico. La CI ci consente di mantenere un codice di alta qualità individuando i problemi precocemente e frequentemente nel processo di sviluppo. In Ultralytics, utilizziamo vari test di CI per garantire la qualità e l'integrità del nostro codebase.
Azioni CI#
Ecco una breve descrizione delle nostre azioni CI:
- CI: Questo è il nostro test CI principale che include l'esecuzione di test unitari, controlli di formattazione (linting) e talvolta test più approfonditi a seconda del repository.
- Docker Deployment: Questo test verifica il rilascio del progetto utilizzando Docker per garantire che il file Dockerfile e gli script correlati funzionino correttamente.
- Broken Links: Questo test analizza la codebase alla ricerca di collegamenti interrotti o non validi nei nostri file markdown o HTML.
- CodeQL: CodeQL è uno strumento di GitHub che esegue un'analisi semantica sul nostro codice, aiutando a trovare potenziali vulnerabilità di sicurezza e a mantenere codice di alta qualità.
- PyPI Publishing: Questo test verifica se il progetto può essere pacchettizzato e pubblicato su PyPI senza errori.
Risultati CI#
Di seguito è riportata la tabella che mostra lo stato di questi test CI per i nostri repository principali:
| Repository | CI | Docker Deployment | Broken Links | CodeQL | PyPI and Docs Publishing |
|---|---|---|---|---|---|
| yolov3 |  |  |  |  | |
| yolov5 |  |  |  |  | |
| ultralytics |  |  |  |  |   |
| yolo-ios-app |  |  |  | ||
| yolo-flutter-app |  |  |  | ||
| thop |  |  |  | ||
| actions |  |  |  | ||
| mkdocs |  |  |  | ||
| docs |  |  | |||
| handbook |  |  | |||
| stars |  |  | |||
| CLIP |  |
Ogni badge mostra lo stato dell'ultima esecuzione del test CI corrispondente sul branch main del rispettivo repository. Se un test fallisce, il badge mostrerà uno stato di fallimento ("failing"), mentre se viene superato, mostrerà uno stato di successo ("passing").
Se noti un test che fallisce, sarebbe di grande aiuto se potessi segnalarlo tramite una GitHub issue nel rispettivo repository.
Ricorda, un test CI riuscito non significa che tutto sia perfetto. Si consiglia sempre di rivedere manualmente il codice prima del deployment o del merge delle modifiche.
Code Coverage#
La code coverage è una metrica che rappresenta la percentuale del tuo codebase che viene eseguita quando i tuoi test sono in esecuzione. Fornisce informazioni su quanto bene i tuoi test esercitano il tuo codice e può essere fondamentale per identificare parti non testate della tua applicazione. Una percentuale elevata di code coverage è spesso associata a una minore probabilità di bug. Tuttavia, è essenziale comprendere che la code coverage non garantisce l'assenza di difetti. Indica semplicemente quali parti del codice sono state eseguite dai test.
Integrazione con codecov.io#
In Ultralytics abbiamo integrato i nostri repository con codecov.io, una popolare piattaforma online per misurare e visualizzare la copertura del codice. Codecov fornisce informazioni dettagliate, confronti di copertura tra commit e sovrapposizioni visive direttamente sul tuo codice, indicando quali righe sono state coperte.
Integrandoci con Codecov, miriamo a mantenere e migliorare la qualità del nostro codice concentrandoci sulle aree che potrebbero essere soggette a errori o che necessitano di ulteriori test.
Risultati della copertura#
Per avere rapidamente una panoramica dello stato di copertura del codice dei nostri repository, abbiamo incluso i badge di Codecov e le anteprime sunburst per ogni progetto tracciato. Il cerchio più interno di ogni sunburst rappresenta l'intero progetto, allontanandosi dal centro ci sono le cartelle e infine, un singolo file. Le dimensioni e il colore di ogni fetta rappresentano rispettivamente il numero di istruzioni e la copertura. Per tutti i dettagli, visita l'organizzazione Codecov di Ultralytics.
| Repository | Code Coverage | Sunburst |
|---|---|---|
| actions |  |  |
| ultralytics |  |  |
| inference |  |  |
| yolo-flutter-app |  |  |
| yolo-ios-app |  |  |
| llm |  |  |
| profile |  |  |
| template |  |  |
| template-rust |  |  |
| replicate |  |  |
FAQ#
La Continuous Integration (CI) in Ultralytics implica l'integrazione e il test automatici delle modifiche al codice per garantire elevati standard di qualità. La nostra configurazione CI include l'esecuzione di test unitari, controlli di formattazione (linting) e test completi. Inoltre, eseguiamo il rilascio con Docker, controlli dei link interrotti, analisi CodeQL per le vulnerabilità di sicurezza e la pubblicazione su PyPI per pacchettizzare e distribuire il nostro software.
Ultralytics utilizza una specifica azione CI per verificare la presenza di link interrotti all'interno dei nostri file markdown e HTML. Questo aiuta a mantenere l'integrità della nostra documentazione scansionando e identificando link non validi o interrotti, assicurando che gli utenti abbiano sempre accesso a risorse accurate e aggiornate.
L'analisi CodeQL è fondamentale per Ultralytics in quanto esegue un'analisi semantica del codice per trovare potenziali vulnerabilità di sicurezza e mantenere elevati standard di qualità. Con CodeQL possiamo identificare e mitigare in modo proattivo i rischi nel nostro codice, aiutandoci a fornire soluzioni software robuste e sicure.
Ultralytics impiega Docker per convalidare il rilascio dei nostri progetti attraverso una specifica azione CI. Questo processo garantisce che il nostro Dockerfile e gli script associati funzionino correttamente, consentendo ambienti di rilascio coerenti e riproducibili, fondamentali per soluzioni di IA scalabili e affidabili.
La pubblicazione su PyPI automatizzata garantisce che i nostri progetti possano essere pacchettizzati e pubblicati senza errori. Questo passaggio è essenziale per distribuire i pacchetti Python di Ultralytics, consentendo agli utenti di installare e utilizzare facilmente i nostri strumenti tramite il Python Package Index (PyPI).
Ultralytics misura la copertura del codice integrandosi con Codecov, fornendo informazioni su quanta parte della codebase viene eseguita durante i test. Un'elevata copertura del codice può indicare un codice ben testato, aiutando a scoprire aree non testate che potrebbero essere soggette a bug. È possibile esplorare metriche dettagliate sulla copertura del codice tramite i badge visualizzati sui nostri repository principali o direttamente su Codecov.