Integrazione continua (CI)#
L'integrazione continua (CI) è un aspetto essenziale dello sviluppo software che consiste nell'integrare le modifiche e testarle automaticamente. La CI ci consente di mantenere il codice di alta qualità individuando i problemi tempestivamente e con frequenza durante il processo di sviluppo. In Ultralytics utilizziamo vari test CI per garantire la qualità e l'integrità della nostra codebase.
Azioni CI#
Ecco una breve descrizione delle nostre azioni CI:
- CI: Questo è il nostro test CI principale e prevede l'esecuzione di test unitari, controlli di linting e, talvolta, test più completi a seconda del repository.
- Distribuzione Docker: Questo test verifica la distribuzione del progetto tramite Docker per assicurarsi che il Dockerfile e gli script correlati funzionino correttamente.
- Link non funzionanti: Questo test analizza la codebase alla ricerca di link non funzionanti o inattivi nei nostri file Markdown o HTML.
- CodeQL: CodeQL è uno strumento di GitHub che esegue un'analisi semantica del nostro codice, contribuendo a individuare potenziali vulnerabilità di sicurezza e a mantenere il codice di alta qualità.
- Pubblicazione su PyPI: Questo test verifica che il progetto possa essere pacchettizzato e pubblicato su PyPI senza errori.
Risultati CI#
Di seguito è riportata la tabella con lo stato di questi test CI per i nostri repository principali:
| Repository | CI | Distribuzione Docker | Link non funzionanti | CodeQL | Pubblicazione su PyPI e della documentazione |
|---|---|---|---|---|---|
| yolov3 |  |  |  |  | |
| yolov5 |  |  |  |  | |
| ultralytics |  |  |  |  |   |
| sdk |  |  | |||
| 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 non riesce, il badge mostrerà lo stato "non riuscito"; se invece viene superato, mostrerà lo stato "superato".
Se noti che un test non riesce, ci sarebbe di grande aiuto segnalarlo tramite una issue di GitHub nel rispettivo repository.
Ricorda: un test CI superato non significa che sia tutto perfetto. È sempre consigliabile esaminare manualmente il codice prima della distribuzione o dell'unione delle modifiche.
Copertura del codice#
La copertura del codice è una metrica che rappresenta la percentuale della tua codebase eseguita durante l'esecuzione dei test. Fornisce informazioni su quanto i test esercitino il codice e può essere fondamentale per identificare le parti non testate della tua applicazione. Una percentuale elevata di copertura del codice è spesso associata a una minore probabilità di bug. Tuttavia, è essenziale capire che la copertura del codice 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 piattaforma online molto utilizzata per misurare e visualizzare la copertura del codice. Codecov fornisce informazioni dettagliate, confronti della copertura tra commit e sovrapposizioni visive direttamente sul codice, indicando quali righe sono state coperte.
Integrando Codecov, puntiamo a mantenere e migliorare la qualità del nostro codice concentrandoci sulle aree che potrebbero essere soggette a errori o richiedere ulteriori test.
Risultati della copertura#
Per avere rapidamente una panoramica dello stato della copertura del codice dei nostri repository, abbiamo incluso badge Codecov e anteprime sunburst per ogni progetto monitorato. Il cerchio più interno di ogni sunburst rappresenta l'intero progetto; allontanandosi dal centro si trovano prima le cartelle e infine un singolo file. La dimensione e il colore di ogni sezione rappresentano rispettivamente il numero di istruzioni e la copertura. Per tutti i dettagli, visita l'organizzazione Ultralytics su Codecov.
| Repository | Copertura del codice | Sunburst |
|---|---|---|
| actions |  |  |
| ultralytics |  |  |
| inference |  |  |
| yolo-flutter-app |  |  |
| yolo-ios-app |  |  |
| llm |  |  |
| profile |  |  |
| template |  |  |
| template-rust |  |  |
| replicate |  |  |
FAQ#
L'integrazione continua (CI) in Ultralytics consiste nell'integrare e testare automaticamente le modifiche al codice per garantire standard di alta qualità. La nostra configurazione CI include l'esecuzione di test unitari, controlli di linting e test completi. Inoltre, eseguiamo la distribuzione Docker, i controlli dei link non funzionanti, l'analisi CodeQL per individuare vulnerabilità di sicurezza e la pubblicazione su PyPI per pacchettizzare e distribuire il nostro software.
Ultralytics utilizza un'azione CI specifica per verificare la presenza di link non funzionanti nei nostri file Markdown e HTML. Questo aiuta a preservare l'integrità della documentazione analizzando e identificando i link inattivi o non funzionanti, così da garantire agli utenti l'accesso costante a risorse accurate e disponibili.
L'analisi CodeQL è fondamentale per Ultralytics perché esegue un'analisi semantica del codice per individuare potenziali vulnerabilità di sicurezza e mantenere standard di alta qualità. Con CodeQL possiamo identificare e mitigare proattivamente i rischi nel nostro codice, contribuendo a fornire soluzioni software solide e sicure.
Ultralytics utilizza Docker per convalidare la distribuzione dei nostri progetti tramite un'azione CI dedicata. Questo processo garantisce che il nostro Dockerfile e gli script associati funzionino correttamente, consentendo ambienti di distribuzione coerenti e riproducibili, fondamentali per soluzioni di intelligenza artificiale scalabili e affidabili.
La pubblicazione automatizzata su PyPI 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 l'Indice dei pacchetti Python (PyPI).
Ultralytics misura la copertura del codice integrandosi con Codecov, fornendo informazioni sulla quantità di codebase eseguita durante i test. Un'elevata copertura del codice può indicare codice ben testato e aiutare a scoprire aree non testate che potrebbero essere soggette a bug. Puoi consultare metriche dettagliate sulla copertura del codice tramite i badge visualizzati nei nostri repository principali o direttamente su Codecov.