Integrazione continua (CI)
L'integrazione continua (CI) è un aspetto essenziale dello sviluppo del software che prevede l'integrazione delle modifiche e il loro collaudo automatico. La CI ci permette di mantenere un codice di alta qualità, individuando i problemi in anticipo e spesso durante il processo di sviluppo. In 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 collegamenti interrotti 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 | Codice SQL | Pubblicazione di PyPI e dei documenti |
|---|---|---|---|---|---|
| yolov3 |  |
 |
 |
 |
|
| yolov5 |  |
 |
 |
 |
|
| ultralytics |  |
 |
 |
 |
 |
| hub-sdk |  |
 |
 |
 |
|
| mozzo |  |
 |
|||
| mkdocs |  |
 |
 |
||
| thop |  |
 |
 |
||
| azioni |  |
 |
 |
||
| documenti |  |
  |
 |
||
| manuale |  |
 |
 |
Ciascun badge mostra lo stato dell'ultima esecuzione del test CI corrispondente sul sistema di gestione delle risorse. main del rispettivo repository. Se un test fallisce, il badge visualizzerà lo stato "failing" (fallito), mentre se passa, visualizzerà lo stato "passing" (superato).
Se notate che un test fallisce, sarebbe di grande aiuto se poteste segnalarlo tramite un problema GitHub nel rispettivo repository.
Ricordare 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 base di codice che viene eseguita durante l'esecuzione dei test. Fornisce indicazioni su quanto i test esercitano il codice e può essere cruciale per identificare le parti non testate dell'applicazione. Un'alta percentuale 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 popolare piattaforma online per la misurazione e la visualizzazione della 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.
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 un'idea dello stato di copertura del codice del progetto ultralytics python abbiamo incluso un distintivo e una visuale a raggiera del ultralytics risultati della copertura. Queste immagini mostrano la percentuale di codice coperta dai nostri test, offrendo una metrica a colpo d'occhio dei nostri sforzi di verifica. Per i dettagli completi, vedere 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, allontanandosi dal centro si trovano le cartelle e, infine, un singolo file. La dimensione e il colore di ciascuna fetta rappresentano rispettivamente il numero di dichiarazioni e la copertura.
FAQ
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 comprende l'esecuzione di test unitari, controlli di linting e test completi. Inoltre, eseguiamo la distribuzione di Docker, il controllo dei collegamenti interrotti, l'analisi di CodeQL per le vulnerabilità di sicurezza e la pubblicazione di PyPI per confezionare e distribuire il nostro software.
Come fa Ultralytics a verificare la presenza di collegamenti interrotti nella documentazione e nel codice?
Ultralytics utilizza un'azione CI specifica per verificare la presenza di collegamenti interrotti 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 vive.
Perché l'analisi CodeQL è importante per Ultralytics' codebase?
L'analisi CodeQL è fondamentale per Ultralytics , in quanto esegue l'analisi semantica del codice per trovare 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 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 la distribuzione dei pacchetti Ultralytics'Python , che consentono agli utenti di installare e utilizzare facilmente i nostri strumenti tramite l'indice dei pacchetti Python (PyPI).
Come misura Ultralytics la copertura del codice e perché è importante?
Ultralytics misura la copertura del codice integrandosi con Codecov, fornendo indicazioni 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 tramite badge visualizzati sui nostri repository principali o direttamente su Codecov.
