Integrazione continua (CI)#
L'integrazione continua (CI) è un aspetto essenziale dello sviluppo software e consiste nell'integrare le modifiche e testarle automaticamente. La CI ci consente di mantenere codice di alta qualità individuando i problemi tempestivamente e con regolarità durante il processo di sviluppo. In Ultralytics utilizziamo diversi test CI per garantire la qualità e l'integrità del nostro codice.
Azioni CI#
Ecco una breve descrizione delle nostre azioni CI:
- CI: è il nostro test CI principale; esegue test unitari e, a seconda del repository, test più approfonditi come controlli di esportazione e benchmark.
- 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 esamina il codice alla ricerca di link non funzionanti o inattivi nei file Markdown o HTML.
- CodeQL: CodeQL è uno strumento di GitHub che esegue l'analisi semantica del codice, aiutandoci a individuare potenziali vulnerabilità di sicurezza e a mantenere codice di alta qualità.
- Pubblicazione su PyPI: questa procedura compila il pacchetto e pubblica ogni nuova versione su PyPI.
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 |  |  |  | ||
| lite |  |  | |||
| openapi |  |  | |||
| skills |  |  | |||
| 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 va a buon fine, il badge mostrerà lo stato "non superato"; se invece viene superato, mostrerà lo stato "superato".
Se noti che un test non va a buon fine, ci faresti un grande favore segnalando il problema tramite una issue su GitHub nel rispettivo repository.
Ricorda che il superamento di un test CI non significa che sia tutto perfetto. È sempre consigliabile esaminare manualmente il codice prima della distribuzione o dell'integrazione delle modifiche.
Copertura del codice#
La copertura del codice è una metrica che rappresenta la percentuale della tua codebase eseguita durante i test. Ti aiuta a capire quanto i test esercitano il codice e può essere fondamentale per individuare le parti dell'applicazione non testate. Una percentuale elevata di copertura del codice è spesso associata a una minore probabilità di bug. Tuttavia, è importante capire che la copertura del codice non garantisce l'assenza di difetti. Indica soltanto 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 della copertura tra commit e sovrapposizioni visive direttamente sul codice, indicando le righe coperte.
Integrando Codecov, puntiamo a mantenere e migliorare la qualità del codice concentrandoci sulle aree che potrebbero essere soggette a errori o richiedere ulteriori test.
Risultati della copertura#
Per visualizzare rapidamente lo stato della copertura del codice nei nostri repository, abbiamo incluso badge Codecov e anteprime sunburst per ogni progetto monitorato. Il cerchio più interno di ogni grafico sunburst rappresenta l'intero progetto; procedendo verso l'esterno si trovano le cartelle e infine i singoli file. Le dimensioni e i colori delle sezioni 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 |  |  |
Domande frequenti#
L'integrazione continua (CI) in Ultralytics consiste nell'integrare e testare automaticamente le modifiche al codice per garantire standard di qualità elevati. La nostra configurazione CI prevede l'esecuzione di test unitari, test di esportazione e benchmark. Inoltre, eseguiamo la distribuzione con Docker, il controllo dei link non funzionanti, l'analisi CodeQL per individuare vulnerabilità di sicurezza e la pubblicazione su PyPI per preparare e distribuire il nostro software.
Ultralytics usa un'azione CI specifica per controllare la presenza di link non funzionanti nei file Markdown e HTML. Questo aiuta a mantenere integra la documentazione, individuando i link non più attivi o non funzionanti e garantendo agli utenti l'accesso a risorse aggiornate e affidabili.
L'analisi CodeQL è fondamentale per Ultralytics perché esegue un'analisi semantica del codice per individuare potenziali vulnerabilità di sicurezza e mantenere standard di qualità elevati. Con CodeQL possiamo identificare e mitigare i rischi nel codice in modo proattivo, aiutandoci a fornire soluzioni software robuste e sicure.
Ultralytics usa Docker per convalidare la distribuzione dei progetti tramite un'azione CI dedicata. Questo processo verifica che il Dockerfile e gli script associati funzionino correttamente, consentendo di creare ambienti di distribuzione coerenti e riproducibili, essenziali per soluzioni di AI affidabili e scalabili.
La pubblicazione automatizzata su PyPI crea i nostri pacchetti e pubblica ogni nuova versione senza passaggi manuali. Questo processo è essenziale per distribuire i pacchetti Python di Ultralytics e consentire agli utenti di installare e usare facilmente i nostri strumenti tramite il Python Package Index (PyPI).
Ultralytics misura la copertura del codice integrandosi con Codecov, che fornisce informazioni sulla quantità di codebase eseguita durante i test. Un'elevata copertura del codice può indicare che il codice è stato testato a fondo e aiutare a individuare aree non testate che potrebbero contenere bug. Puoi consultare le metriche dettagliate di copertura del codice tramite i badge mostrati nei nostri repository principali o direttamente su Codecov.