HAYDN ELLEN

Questa settimana ho pensato molto al flusso di lavoro. Osservando i miei compiti quotidiani, mi sono reso conto che impostare i progetti Django stava prendendo più tempo del necessario. Installare Django è veloce, soprattutto usando Astral-UV, che lo fa funzionare in meno di un minuto. Ma questo è solo l'inizio. Dopo l'installazione, avrei dedicato tempo agli stessi noiosi passaggi: creare strutture di directory, impostare modelli, aggiungere file essenziali come urls.py e forms.py e creare file HTML segnaposto per pagine come la home page e la pagina dei contatti. Queste attività ripetitive si sono sommate, quindi ho deciso di automatizzare il più possibile il processo di installazione di Django e di risparmiare una notevole quantità di tempo.

La flessibilità di Python lo rende ideale per l'automazione. I suoi strumenti per la gestione dei file, la gestione dei sottoprocessi e l'analisi della riga di comando erano perfetti per creare uno strumento in grado di gestire tutta la configurazione di cui avevo bisogno. Ho strutturato lo strumento con classi modulari per ogni parte del processo di configurazione, quindi è stato facile adattarlo se avessi voluto apportare modifiche in futuro. Volevo anche che lo strumento fosse facile da usare, quindi l'ho progettato per funzionare con un singolo comando. Tutto ciò di cui ho bisogno è eseguire python3 main.py <nome_progetto> <nome_app_facoltativo> dalla directory di primo livello in cui voglio creare progetti Django. Questo comando si occupa di tutto: installa Django, crea un'app facoltativa, imposta la struttura di directory corretta e genera file essenziali con contenuto segnaposto.

Questo script funziona solo sui sistemi basati su Debian (Debian, Ubuntu, ecc.).

Il primo passaggio nello script è il controllo del software necessario, come snapd e uv. Ho utilizzato il modulo subprocess di Python per eseguire questi controlli. Ecco come l'ho gestito per snapd:

 import subprocess def check_snapd_installed(): """Check if 'snapd' is installed by trying to call the snap version command.""" try: subprocess.run(['snap', '--version'], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) print("'snapd' is already installed.") return True except FileNotFoundError: print("'snapd' is not found; it needs to be installed.") return False

Questa funzione controlla snapd chiamando snap –version. Se il comando restituisce un errore, lo script mi fa sapere che snapd è mancante e chiede di installarlo. Ho usato funzioni simili per altre dipendenze, assicurandomi di poter eseguire lo strumento su qualsiasi sistema e avere comunque pronto il software necessario.

Impostare la struttura della directory del progetto è stato un po' più impegnativo. Ho dovuto considerare i casi in cui un utente avrebbe potuto immettere un percorso relativo o un percorso già esistente. Per evitare conflitti di directory e impedire l'utilizzo di nomi riservati di Django come static o media, lo script convalida il nome della directory e, se c'è un problema, richiede un nuovo nome. Una volta convalidata e creata la directory, UV gestisce la configurazione del backend, inclusa l'inizializzazione dell'ambiente virtuale, l'aggiunta di Django e la creazione di un file .gitignore. Ecco uno snippet che gestisce la configurazione della directory:

 def prompt_for_directory(): """Prompt user for the directory where the Django project should be installed.""" disallowed_names = {'test', 'django', 'site', 'admin', 'main', 'manage', 'static', 'templates', 'media'} while True: directory = input("Enter the directory where you want to install the Django project: ") directory_name = os.path.basename(os.path.normpath(directory)) if directory_name.lower() in disallowed_names: print(f"The directory name '{directory_name}' is reserved and cannot be used.") else: os.makedirs(directory, exist_ok=True) os.chdir(directory) print(f"Changed directory to {directory}") break

Questa configurazione garantisce che il nome della directory scelto non entri in conflitto con i nomi riservati, il che previene potenziali problemi in futuro.

Una parte noiosa dell'impostazione di un progetto Django è la configurazione delle variabili di ambiente, quindi ho automatizzato questa operazione facendo in modo che lo strumento generasse automaticamente i file .env e .env-template nella root del progetto. Ogni file è precompilato con valori predefiniti come DEBUG=True, segnaposto per SECRET_KEY e DATABASE_URL. Ciò consente di risparmiare tempo e garantisce un'impostazione coerente nei progetti. Ecco lo snippet che crea questi file:

 env_content = ( "# Environment variables\n" "DEBUG=True\n" "SECRET_KEY=your-secret-key\n" "DATABASE_URL=your-database-url\n" ) with open(".env", 'w') as f: f.write(env_content) print("Created .env in the installation directory.") with open(".env-template", 'w') as f: f.write(env_content) print("Created .env-template in the installation directory.")

Con questi Grazie ai file configurati automaticamente, ogni nuovo progetto Django è pronto per le variabili d'ambiente fin dall'inizio, il che mi evita di dover aggiungere queste configurazioni manualmente.

Lo strumento crea anche automaticamente file di progetto essenziali come base.html e directory per template e asset statici. Lo script imposta sottodirectory per CSS, JavaScript e immagini all'interno della cartella static, insieme a una cartella partials nella directory principale dei template. Per la directory dei template dell'app, crea file HTML di base come index.html, about.html e contact.html con contenuto segnaposto. Ecco come appare quella sezione nel codice:

 html_files = { "index.html": " ", "about.html": " ", "contact.html": " ", } for filename, content in html_files.items(): with open(f"{app_template_path}/{filename}", 'w') as f: f.write(content) print(f"Created {filename} in {app_template_path}")

Questa semplice configurazione garantisce coerenza e mi evita di dover creare ripetutamente questi file manualmente.

Per usare lo strumento, mi basta andare a una directory di primo livello in cui voglio i miei progetti Django ed eseguire python3 main.py <nome_progetto> <nome_app_facoltativo>. Questo comando fa tutto. Controlla le dipendenze, imposta la directory, installa Django con UV, crea template e file statici, inizializza Git e genera file di configurazione, il tutto in pochi secondi. Posso iniziare a programmare immediatamente con un progetto completamente strutturato, saltando tutte le attività di configurazione ripetitive.

Questo strumento è diventato un enorme risparmio di tempo per me. Automatizzando la configurazione, ho eliminato il lavoro noioso che prima accompagnava ogni nuovo progetto Django. Ora, invece di perdere tempo sulla struttura delle directory e sulla creazione di file, posso passare direttamente allo sviluppo con una configurazione pulita e coerente ogni volta. La flessibilità di Python ha reso possibile questo strumento e ho già iniziato a pensare ad altre funzionalità da aggiungere in futuro. Per chiunque lavori regolarmente con Django, questo strumento è un punto di svolta, consentendo di dedicare più tempo alla creazione e meno alla configurazione.

Puoi vedere lo script completo nel repository Github che ho configurato per il progetto.