Dimentica PIP, Conda e requirements.txt! Usa Poetry invece e ringraziami dopo

Usa Poetry e ringraziami dopo!

 

La Libreria A richiede Python 3.6. La Libreria B si basa sulla Libreria A ma ha bisogno di Python 3.9, e la Libreria C dipende dalla Libreria B ma richiede la versione specifica della Libreria A che è compatibile con Python 3.6.

Benvenuti nell’inferno delle dipendenze!

Dato che il Python nativo è inutile senza pacchetti esterni per la scienza dei dati, gli scienziati dei dati possono spesso trovarsi intrappolati in situazioni di dipendenza come quella sopra descritta.

• Migliori GPU per l’IA e il Deep Learning
• Un inventario nidificato per la sicurezza del software, la gestione del rischio della catena di fornitura
• Una Benedizione e un Babau Gli inserzionisti accolgono con cautela l’Intelligenza Artificiale.

Strumenti come PIP, Conda o i ridicoli file requirements.txt non possono risolvere questo problema. In realtà, gli incubi delle dipendenze esistono in gran parte a causa di loro. Quindi, per porre fine alle loro sofferenze, la comunità open source di Python ha sviluppato lo strumento affascinante noto come Poetry.

Poetry è un framework di gestione di progetti e dipendenze all-in-one con oltre 25k stelle su GitHub. Questo articolo introdurrà Poetry e elencherà i problemi che risolve per gli scienziati dei dati.

Cominciamo.

 

Installazione

 

Anche se Poetry può essere installato come una libreria con PIP, si consiglia di installarlo a livello di sistema in modo da poter chiamare poetry da qualsiasi punto del CLI. Ecco il comando che esegue lo script di installazione per i sistemi Unix-like, compreso Windows WSL2:

curl -sSL https://install.python-poetry.org | python3 -

 

Se, per qualche strano motivo, si utilizza Windows Powershell, ecco il comando adatto:

(Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | py -

 

Per verificare se Poetry è stato installato correttamente, è possibile eseguire:

$ poetry -v

Poetry (versione 1.5.1)

 

Poetry supporta anche il completamento del tab per una varietà di shell come Bash, Fish, Zsh, ecc. Ulteriori informazioni a riguardo possono essere trovate qui.

 

1. Struttura coerente per tutti i progetti

 

Poiché Poetry è uno strumento all-in-one, è possibile utilizzarlo dall’inizio alla fine del progetto.

Quando si avvia un nuovo progetto, è possibile eseguire poetry new nome_progetto. Verrà creata una struttura di directory predefinita che è quasi pronta per essere costruita e pubblicata su PyPI come un pacchetto Python:

$ poetry new binary_classification
Pacchetto binary_classification creato in binary_classification

$ ls binary_classification
README.md  binary_classification  pyproject.toml  tests

$ tree binary_classification/

binary_classification
├── pyproject.toml
├── README.md
├── binary_classification
│   └── __init__.py
└── tests
    └── __init__.py

 

Ma noi, scienziati dei dati, raramente creiamo pacchetti Python, quindi si consiglia di avviare il progetto da soli e chiamare poetry init all’interno:

$ mkdir binary_classification
$ poetry init

 

La CLI ti farà alcune domande per la configurazione, ma puoi lasciare la maggior parte di esse vuote in quanto possono essere aggiornate in seguito:

   

Il comando init produrrà il file più critico di Poetry, ovvero pyproject.toml. Il file contiene alcuni metadati del progetto, ma soprattutto elenca le dipendenze:

$ cat pyproject.toml
[tool.poetry]
name = "binary-classification"
version = "0.1.0"
description = "Un progetto di classificazione binaria con scikit-learn."
authors = ["Bex Tuychiev "]
readme = "README.md"
packages = [{include = "binary_classification"}]

[tool.poetry.dependencies]
python = "^3.9"


[build-system]
requires = ["poetry-core"]
build-backend = "poetry.core.masonry.api"

 

Al momento, la sola dipendenza sotto tool.poetry.dependencies è Python 3.9 (impareremo cosa significa ^ in seguito). Popoliamolo con più librerie.

Se vuoi scoprire cosa fanno tutti i campi nel file pyproject.toml, vai qui.

2. Specifica delle dipendenze

 

Per installare le dipendenze per il tuo progetto, non dovrai più utilizzare PIP o Conda, almeno direttamente. Invece, inizierai a utilizzare i comandi poetry add nome_libreria.

Ecco un esempio:

$ poetry add scikit-learn@latest

 

Aggiungendo il flag @latest si installa la versione più recente di Sklearn da PyPI. È anche possibile aggiungere più dipendenze senza alcun flag (vincoli):

$ poetry add requests pandas numpy plotly seaborn

 

La bellezza di add è che se i pacchetti specificati non hanno vincoli di versione, troverà le versioni di tutti i pacchetti che risolvono, ovvero non lanceranno errori quando installati insieme. Verificherà anche le dipendenze già specificate in pyproject.toml.

$ cat pyproject.toml
[tool.poetry]
...

[tool.poetry.dependencies]
python = "^3.9"
numpy = "^1.25.0"
scikit-learn = "^1.2.2"
requests = "^2.31.0"
pandas = "^2.0.2"
plotly = "^5.15.0"
seaborn = "^0.12.2"

 

Proviamo a ridurre la versione di numpy a v1.24 e vediamo cosa succede:

$ poetry add numpy==1.24

...
Perché seaborn (0.12.2) dipende da numpy (>=1.17,<1.24.0 || >1.24.0) ...
la risoluzione delle versioni ha fallito.

 

Poetry non lo permetterà perché la versione ridotta sarebbe in conflitto con Seaborn. Se fosse PIP o conda, installerebbero volentieri Numpy 1.24 e ci sorriderebbero mentre l’incubo inizia.

Oltre alle installazioni standard, Poetry fornisce una sintassi versatile per definire i vincoli di versione. Questa sintassi ti permette di specificare versioni esatte, stabilire limiti per intervalli di versione (superiore a, inferiore a o compreso tra) e fissare le versioni principali, minori o di correzione. Le seguenti tabelle, tratte dalla documentazione di Poetry (Licenza MIT), servono come esempi.

Requisiti del caret:

   

Requisiti della tilde:

   

Requisiti del wildcard:

   

Per specifiche di vincolo ancora più avanzate, visita questa pagina della documentazione di Poetry.

 

3. Gestione dell’ambiente

 

Una delle funzionalità principali di Poetry è isolare l’ambiente del progetto dal namespace globale nel modo più efficiente possibile.

Quando esegui il comando poetry add libreria, ecco cosa succede:

1. Se hai inizializzato Poetry all’interno di un progetto esistente con un ambiente virtuale già attivato, la libreria verrà installata in quell’ambiente (può essere qualsiasi gestore di ambiente come Conda, venv, ecc.).
2. Se hai creato un progetto vuoto con poetry new o inizializzato Poetry con init quando nessun ambiente virtuale è attivato, Poetry creerà un nuovo ambiente virtuale per te.

Quando si verifica il caso 2, l’ambiente risultante sarà nella cartella /home/user/.cache/pypoetry/virtualenvs/. L’eseguibile Python sarà presente lì da qualche parte.

Per vedere quale ambiente creato da Poetry è attivo, è possibile eseguire il comando poetry env list:

$ poetry env list

test-O3eWbxRl-py3.6

binary_classification-O3eWbxRl-py3.9 (Attivato)

Per passare tra gli ambienti creati da Poetry, è possibile eseguire il comando poetry env use:

$ poetry env use other_env

È possibile saperne di più sulla gestione degli ambienti qui.

Quando si esegue il comando add, Poetry genererà un file poetry.lock. Invece di specificare vincoli di versione come 1.2.*, blocca le versioni esatte delle librerie che si stanno utilizzando, come 1.2.11. Tutte le esecuzioni successive di poetry add o poetry update modificheranno il file di blocco per riflettere le modifiche.

L’utilizzo di tali file di blocco garantisce che le persone che utilizzano il vostro progetto possano riprodurre completamente l’ambiente sulle loro macchine.

Le persone hanno a lungo utilizzato alternative come requirements.txt, ma il suo formato è molto libero e soggetto a errori. Un tipico requirements.txt creato dall’uomo non è accurato, in quanto gli sviluppatori di solito non si preoccupano di elencare le versioni esatte delle librerie che stanno utilizzando e semplicemente indicano intervalli di versione o, peggio ancora, scrivono solo il nome della libreria.

Poi, quando gli altri cercano di riprodurre l’ambiente con pip install -r requirements.txt, PIP stesso cerca di risolvere i vincoli di versione, ed è così che ci si ritrova silenziosamente nell’inferno delle dipendenze.

Quando si utilizza Poetry e i file di blocco, nulla di tutto ciò accade. Quindi, se si sta inizializzando Poetry in un progetto con già presente un requirements.txt, è possibile aggiungere le dipendenze al suo interno con:

$ poetry add `cat requirements.txt`

e cancellare il requirements.txt.

Tuttavia, si prega di notare che alcuni servizi come Streamlit o Heroku richiedono ancora vecchi file requirements.txt per il deployment. Quando si utilizzano questi, è possibile esportare il file poetry.lock in un formato di testo con:

$ poetry export --output requirements.txt

Vorrei concludere l’articolo con un workflow passo-passo per integrare Poetry in qualsiasi progetto di dati.

Passo 0: Installare Poetry per il proprio sistema.

Passo 1: Creare un nuovo progetto con mkdir e chiamare poetry init al suo interno per inizializzare Poetry. Se si desidera convertire il progetto successivamente in un pacchetto Python, creare il progetto con poetry new nome_progetto.

Passo 2: Installare e aggiungere le dipendenze con poetry add nome_libreria. È anche possibile modificare manualmente il file pyproject.toml e aggiungere le dipendenze nella sezione [tool.poetry.dependencies]. In questo caso, è necessario eseguire poetry install per risolvere i vincoli di versione e installare le librerie.

Dopo questo passaggio, Poetry crea un ambiente virtuale per il progetto e genera un file poetry.lock.

Passo 3: Inizializzare Git e altri strumenti come DVC e iniziare a tenere traccia dei file appropriati. Mettere i file pyproject.toml e poetry.lock sotto Git.

Passo 4: Sviluppare il proprio codice e modelli. Per eseguire gli script Python, è necessario utilizzare poetry run python script.py in modo che venga utilizzato l’ambiente virtuale di Poetry.

Passo 5: Testare il proprio codice e apportare eventuali modifiche necessarie. Iterare sull’analisi dei dati o sugli algoritmi di machine learning, sperimentare con diverse tecniche e raffinare il codice secondo necessità.

Passaggi opzionali:

1. Per aggiornare le dipendenze già installate, utilizzare il comando poetry update library. L’aggiornamento funziona solo all’interno dei vincoli definiti in pyproject.toml, quindi controllare qui le avvertenze.
2. Se si parte da un progetto con il file requirements.txt, utilizzare poetry add cat requirements.txt per aggiungere automaticamente e installare le dipendenze.
3. Se si desidera esportare il file poetry.lock, è possibile utilizzare il comando poetry export --output requirements.txt.
4. Se è stata scelta una struttura di pacchetto per il progetto (poetry add), è possibile compilare il pacchetto con il comando poetry build e sarà pronto per essere caricato su PyPI.
5. Cambiare tra ambienti virtuali con il comando poetry env use other_env.

Con questi passaggi, ci si assicurerà di non finire più nell’inferno delle dipendenze.

Grazie per la lettura!

Bex Tuychiev è uno degli autori AI più popolari su VoAGI e un Kaggle Master con oltre 15.000 follower. Ama scrivere guide dettagliate, tutorial e notebook su argomenti complessi di data science e machine learning con un tocco sarcastico.

Originale. Ripubblicato con il permesso dell’autore.