Integrazione continua (CI)
L'integrazione continua (CI) è un aspetto essenziale dello sviluppo del software che prevede l'integrazione delle modifiche e il loro test automatico. La CI ci permette di mantenere un codice di alta qualità individuando i problemi nelle prime fasi del processo di sviluppo. Su Ultralytics utilizziamo diversi test di CI per garantire la qualità e l'integrità della nostra base di codice.
Azioni dell'IC
Ecco una breve descrizione delle nostre azioni di CI:
- CI: è il nostro test CI principale che 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 utilizzando Docker per assicurarsi che il file Docker e i relativi script funzionino correttamente.
- Collegamenti interrotti: Questo test analizza il codice alla ricerca di eventuali link rotti o morti nei nostri file markdown o HTML.
- CodeQL: CodeQL è uno strumento di GitHub che esegue un'analisi semantica del nostro codice, aiutandoci a trovare potenziali vulnerabilità di sicurezza e a mantenere un codice di alta qualità.
- Pubblicazione su PyPI: questo test verifica se il progetto può essere impacchettato e pubblicato su PyPi senza errori.
Risultati dell'IC
Di seguito è riportata una tabella che mostra lo stato di questi test CI per i nostri repository principali:
| Repository | CI | Distribuzione di Docker | Collegamenti interrotti | CodeQL | Pubblicazione di PyPI e Docs |
|---|---|---|---|---|---|
| yolov3 |  |
 |
 |
 |
|
| yolov5 |  |
 |
 |
 |
|
| ultralytics |  |
 |
 |
 |
 |
| hub |  |
 |
|||
| documenti |   |
 |
Ciascun badge mostra lo stato dell'ultima esecuzione del test CI corrispondente sul sito main del rispettivo repository. Se un test fallisce, il badge mostrerà lo stato "failing" (fallito), mentre se passa, mostrerà lo stato "passing" (superato).
Se noti che un test fallisce, sarebbe di grande aiuto se potessi segnalarlo tramite un problema GitHub nel rispettivo repository.
Ricorda che un test CI riuscito non significa che tutto sia perfetto. È sempre consigliabile rivedere manualmente il codice prima di distribuire o unire le modifiche.
Copertura del codice
La copertura del codice è una metrica che rappresenta la percentuale della tua base di codice che viene eseguita durante l'esecuzione dei test. Fornisce un'idea di quanto i test esercitino il codice e può essere fondamentale per identificare le parti non testate dell'applicazione. Un'alta percentuale di copertura del codice è spesso associata a una minore probabilità di bug. Tuttavia, è fondamentale 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
Su Ultralytics abbiamo integrato i nostri repository con codecov.io, una famosa piattaforma online per misurare e visualizzare la copertura del codice. Codecov fornisce approfondimenti dettagliati, confronti di copertura tra i commit e sovrapposizioni visive direttamente sul codice, indicando quali linee sono state coperte.
Grazie all'integrazione con Codecov, ci proponiamo di 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 un'idea dello stato di copertura del codice del file ultralytics python Abbiamo incluso un badge e una visuale a raggiera dell'immagine del ultralytics risultati della copertura. Queste immagini mostrano la percentuale di codice coperta dai nostri test, offrendo un'indicazione immediata dei nostri sforzi di testing. Per maggiori dettagli, consulta https://codecov.io/github/ultralytics/ultralytics.
| Repository | Copertura del codice |
|---|---|
| ultralytics |  |
Nel grafico a raggiera qui sotto, il cerchio più interno rappresenta l'intero progetto, mentre allontanandosi dal centro si trovano le cartelle e, infine, un singolo file. La dimensione e il colore di ogni fetta rappresentano rispettivamente il numero di dichiarazioni e la copertura.
DOMANDE FREQUENTI
Cos'è l'integrazione continua (CI) in Ultralytics?
La Continuous Integration (CI) in Ultralytics prevede l'integrazione e il test automatico delle 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 il deploy di Docker, il controllo dei collegamenti interrotti, l'analisi di CodeQL per le vulnerabilità di sicurezza e la pubblicazione di PyPI per pacchettizzare e distribuire il nostro software.
Come fa Ultralytics a verificare la presenza di link interrotti nella documentazione e nel codice?
Ultralytics utilizza un'azione CI specifica per verificare la presenza di link non funzionanti all'interno dei nostri file markdown e HTML. Questo aiuta a mantenere l'integrità della nostra documentazione scansionando e identificando i link morti o rotti, assicurando che gli utenti abbiano sempre accesso a risorse accurate e aggiornate.
Perché l'analisi di CodeQL è importante per Ultralytics' codebase?
L'analisi di CodeQL è fondamentale per Ultralytics in quanto esegue un'analisi semantica del codice per individuare potenziali vulnerabilità di sicurezza e mantenere standard di alta qualità. Con CodeQL, possiamo identificare e mitigare in modo proattivo i rischi nel nostro codice, aiutandoci a fornire soluzioni software robuste e sicure.
In che modo Ultralytics utilizza Docker per la distribuzione?
Ultralytics utilizza Docker per convalidare la distribuzione dei nostri progetti attraverso un'azione CI dedicata. Questo processo garantisce che il nostro file Docker e gli script associati funzionino correttamente, consentendo di creare ambienti di distribuzione coerenti e riproducibili, fondamentali per soluzioni di intelligenza artificiale scalabili e affidabili.
Qual è il ruolo della pubblicazione automatica su PyPI in Ultralytics?
La pubblicazione automatica su PyPI garantisce che i nostri progetti possano essere pacchettizzati e pubblicati senza errori. Questo passaggio è essenziale per distribuire i pacchetti Ultralytics'Python , consentendo agli utenti di installare e utilizzare facilmente i nostri strumenti tramite il Python Package Index (PyPI).
Come misura Ultralytics la copertura del codice e perché è importante?
Ultralytics misura la copertura del codice integrandosi con Codecov, fornendo informazioni su quanta parte della base di codice viene eseguita durante i test. Un'elevata copertura del codice può indicare un codice ben testato, aiutando a scoprire le aree non testate che potrebbero essere soggette a bug. Le metriche dettagliate di copertura del codice possono essere esplorate attraverso i badge visualizzati sui nostri repository principali o direttamente su Codecov.