Integrazione Continua (CI)
L'integrazione continua (CI) è un aspetto essenziale dello sviluppo software che implica l'integrazione delle modifiche e il loro test automatico. La CI ci consente di mantenere un codice di alta qualità individuando i problemi in modo precoce e frequente nel 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 che prevede l'esecuzione di unit test, controlli di linting e, a volte, test più completi a seconda del repository.
- Implementazione Docker: Questo test verifica l'implementazione del progetto utilizzando Docker per garantire che il Dockerfile e gli script correlati funzionino correttamente.
- Link non funzionanti: Questo test esegue la scansione del codebase alla ricerca di link non funzionanti o interrotti nei nostri file markdown o HTML.
- CodeQL: CodeQL è uno strumento di GitHub che esegue l'analisi semantica del nostro codice, aiutando 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 CI
Di seguito è riportata la tabella che mostra 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 |  |
 |
 |
 |
  |
| yolo-ios-app |  |
 |
 |
||
| yolo-flutter-app |  |
 |
 |
||
| hub |  |
 |
|||
| hub-sdk |  |
 |
 |
 |
|
| thop |  |
 |
 |
||
| azioni |  |
 |
 |
||
| mkdocs |  |
 |
 |
||
| documenti |  |
  |
 |
||
| manuale |  |
 |
 |
Ogni badge mostra lo stato dell'ultima esecuzione del test CI corrispondente sul main branch del rispettivo repository. Se un test fallisce, il badge visualizzerà uno stato di "fallimento", e se passa, visualizzerà uno stato di "superamento".
Se noti un test fallito, sarebbe di grande aiuto se potessi segnalarlo tramite un issue di GitHub nel repository corrispondente.
Ricorda, un test CI riuscito non significa che tutto sia perfetto. È sempre consigliabile rivedere manualmente il codice prima della distribuzione o dell'unione delle modifiche.
Copertura del codice
La copertura del codice è una metrica che rappresenta la percentuale del tuo codebase che viene eseguita quando vengono eseguiti i tuoi test. Fornisce informazioni su quanto bene i tuoi test esercitino il tuo codice e può essere fondamentale per identificare le parti non testate della tua 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 piattaforma online popolare per la misurazione e la visualizzazione della code coverage. Codecov fornisce informazioni dettagliate, confronti della coverage tra i commit e sovrapposizioni visive direttamente sul 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 necessitare di ulteriori test.
Risultati di Copertura
Per avere rapidamente una panoramica dello stato di code coverage del ultralytics pacchetto python, abbiamo incluso un badge e una visualizzazione sunburst del ultralytics risultati di copertura. Queste immagini mostrano la percentuale di codice coperta dai nostri test, offrendo una metrica immediata dei nostri sforzi di test. Per tutti i dettagli, consultare https://codecov.io/github/ultralytics/ultralytics.
| Repository | Copertura del codice |
|---|---|
| ultralytics |  |
Nel grafico sunburst sottostante, il cerchio più interno è l'intero progetto, allontanandosi dal centro ci sono le cartelle e, infine, un singolo file. La dimensione e il colore di ogni fetta rappresentano rispettivamente il numero di istruzioni e la copertura.
FAQ
Cos'è l'Integrazione Continua (CI) in Ultralytics?
L'Integrazione Continua (CI) in Ultralytics prevede l'integrazione e il test automatici delle modifiche al codice per garantire standard di alta qualità. La nostra configurazione CI include l'esecuzione di unit test, controlli di linting e test completi. Inoltre, eseguiamo il deployment Docker, i controlli dei link interrotti, l'analisi CodeQL per le vulnerabilità di sicurezza e la pubblicazione PyPI per confezionare e distribuire il nostro software.
In che modo Ultralytics verifica la presenza di link non funzionanti nella documentazione e nel codice?
Ultralytics utilizza una specifica azione CI 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 link interrotti o non funzionanti, garantendo che gli utenti abbiano sempre accesso a risorse accurate e attive.
Perché l'analisi CodeQL è importante per la codebase di Ultralytics?
L'analisi CodeQL è fondamentale per Ultralytics in quanto esegue l'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.
In che modo Ultralytics utilizza Docker per il deployment?
Ultralytics utilizza Docker per convalidare la distribuzione dei nostri progetti attraverso 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 IA scalabili e affidabili.
Qual è il ruolo della pubblicazione automatizzata su PyPI in Ultralytics?
La pubblicazione automatizzata su PyPI garantisce che i nostri progetti possano essere impacchettati 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).
In che modo Ultralytics misura la copertura del codice e perché è importante?
Ultralytics misura la code coverage integrandosi con Codecov, fornendo informazioni su quanta parte del codice viene eseguita durante i test. Un'alta code coverage può indicare un codice ben testato, aiutando a scoprire aree non testate che potrebbero essere soggette a bug. Le metriche dettagliate della code coverage possono essere esplorate tramite i badge visualizzati sui nostri repository principali o direttamente su Codecov.
