Introduction

Python est largement connu pour sa polyvalence et sa facilité d'utilisation, en particulier lors de la création d'applications d'interface de ligne de commande (CLI). Que vous souhaitiez automatiser des tâches banales, créer des outils de développement ou créer des scripts flexibles, le riche écosystème de Python propose diverses bibliothèques pour gérer efficacement la CLI.

Dans cet article de blog, nous approfondirons l'utilisation des CLI en Python, en couvrant les points suivants :

• Pourquoi créer une CLI ?
• Modules Python pour créer des CLI
• Les bases des arguments de ligne de commande
• Fonctionnalités avancées utilisant argparse
• Créer des outils CLI en un clic
• Gestion des erreurs dans les outils CLI
• Emballage d'outils CLI pour la distribution

À la fin de cet article, vous serez équipé pour créer des applications en ligne de commande robustes et conviviales.

Pourquoi créer une CLI ?

Les CLI sont largement utilisées dans l'administration système, le traitement des données et le développement de logiciels car elles offrent :

1. Automation : scriptez des tâches répétitives pour gagner du temps et réduire les erreurs.
2. Simplicité : exécutez des commandes complexes en quelques frappes.
3. Portabilité : un outil CLI bien conçu peut être utilisé sur n'importe quelle machine sans interface graphique.
4. Outils de développement : de nombreux outils de développement (comme git, npm et pip) sont basés sur CLI.

Modules Python pour le développement CLI

Python propose plusieurs bibliothèques pour créer des outils CLI :

1. sys.argv : accès direct aux arguments de ligne de commande, adapté aux petits scripts simples.
2. argparse : module intégré pour gérer les arguments de ligne de commande avec génération automatique d'aide.
3. click : une bibliothèque puissante et flexible pour créer des applications CLI complexes.
4. typer : une bibliothèque moderne construite sur le clic, qui utilise des astuces de type Python pour une utilisation plus facile.

Travailler avec sys.argv

sys.argv est un moyen simple d'accéder aux arguments de ligne de commande. Il stocke les arguments de la ligne de commande sous forme de liste, où le premier élément est toujours le nom du script.

import sys

# Command-line arguments
print(f"Script Name: {sys.argv[0]}")
print(f"Arguments: {sys.argv[1:]}")

Exécution du script :

$ python script.py arg1 arg2 arg3
Script Name: script.py
Arguments: ['arg1', 'arg2', 'arg3']

Limites de sys.argv :

• Aucune vérification de type : toutes les entrées sont traitées comme des chaînes.
• Aucun message d'aide intégré : vous devez valider manuellement les entrées et afficher les informations d'utilisation.

Créer des CLI avec argparse

Le module argparse est la bibliothèque standard de Python pour créer des CLI. Il offre plus de contrôle que sys.argv et génère automatiquement des messages d'aide et une gestion des erreurs.

Exemple de base :

import argparse

parser = argparse.ArgumentParser(description="A simple CLI tool")
parser.add_argument("name", help="Your name")
parser.add_argument("--greet", help="Custom greeting", default="Hello")

args = parser.parse_args()

print(f"{args.greet}, {args.name}!")

Exécution du script :

$ python script.py Alice
Hello, Alice!

$ python script.py Alice --greet Hi
Hi, Alice!

Principales fonctionnalités d'argparse :

1. Arguments positionnels et facultatifs : définissez facilement les paramètres obligatoires et facultatifs.
2. Vérification du type : assurez-vous que l'utilisateur fournit le type de données correct.
3. Choix : restreindre les entrées à des valeurs spécifiques à l'aide du paramètre choix.
4. Messages d'aide : génère automatiquement de l'aide avec l'indicateur -h ou --help.

Exemple avec vérification de type et choix :

parser.add_argument("age", type=int, help="Your age")
parser.add_argument("--format", choices=["json", "xml"], help="Output format")

Exécution du script :

$ python script.py Alice 30 --format json

Outils CLI avancés avec clic

click est une bibliothèque plus avancée pour créer des interfaces de ligne de commande. Il fournit une approche basée sur un décorateur pour définir les commandes, les sous-commandes et les options.

Pourquoi utiliser le clic ?

• Meilleure lisibilité : une syntaxe plus pythonique, basée sur un décorateur.
• Validation automatique des arguments : garantit que les arguments sont correctement validés.
• Composants réutilisables : les commandes, options et arguments peuvent être facilement réutilisés dans différentes parties de votre application.

Exemple de base utilisant click :

import click

@click.command()
@click.option('--name', prompt='Your name', help='The person to greet.')
@click.option('--greet', default="Hello", help='Greeting to use.')
def greet(name, greet):
    """Simple program that greets NAME with a GREET."""
    click.echo(f'{greet}, {name}!')

if __name__ == '__main__':
    greet()

Exécution du script :

$ python greet.py --name Alice --greet Hi
Hi, Alice!

Sous-commandes avec clic :

Vous pouvez créer des outils CLI plus complexes avec plusieurs sous-commandes.

import click

@click.group()
def cli():
    pass

@cli.command()
def start():
    click.echo("Starting the application...")

@cli.command()
def stop():
    click.echo("Stopping the application...")

if __name__ == '__main__':
    cli()

Exécution du script :

$ python app.py start
Starting the application...

$ python app.py stop
Stopping the application...

Gestion des erreurs dans les outils CLI

Quelle que soit la bibliothèque que vous utilisez, la gestion des erreurs est cruciale pour offrir une expérience utilisateur fluide.

Exemple dans argparse :

Si un argument obligatoire est manquant, argparse générera une erreur et affichera les instructions d'utilisation :

$ python script.py
usage: script.py [-h] name
script.py: error: the following arguments are required: name

Gestion des erreurs en clic :

En un clic, vous pouvez générer des exceptions personnalisées et gérer les erreurs avec élégance à l'aide de décorateurs.

@click.command()
@click.option('--count', type=int, help='Number of repetitions')
def repeat(count):
    if count is None or count 







  
  
  Combiner argparse et cliquer avec d'autres bibliothèques


Pour étendre la fonctionnalité CLI, vous pouvez combiner argparse ou click avec d'autres bibliothèques comme os, subprocess ou même des bibliothèques personnalisées.


  
  
  Exemple : Combiner argparse avec os




import os
import argparse

parser = argparse.ArgumentParser(description="File operations CLI")
parser.add_argument("filename", help="Name of the file to check")
parser.add_argument("--create", action="store_true", help="Create the file if it does not exist")

args = parser.parse_args()

if os.path.exists(args.filename):
    print(f"{args.filename} already exists.")
else:
    if args.create:
        with open(args.filename, 'w') as f:
            f.write("New file created.")
        print(f"{args.filename} created.")
    else:
        print(f"{args.filename} does not exist.")




Exécution du script :



$ python filecli.py example.txt --create
example.txt created.








  
  
  Emballage de votre outil CLI


Pour distribuer votre outil CLI, vous pouvez le packager à l'aide des outils de configuration et le rendre accessible globalement sur n'importe quel système.


  
  
  Étape 1 : Créer un fichier setup.py




from setuptools import setup

setup(
    name='greet-cli',
    version='0.1',
    py_modules=['greet'],
    install_requires=[
        'click',
    ],
    entry_points='''
        [console_scripts]
        greet=greet:greet
    ''',
)





  
  
  Étape 2 : Installez votre CLI localement




$ pip install --editable .




Désormais, la commande greet est disponible dans le monde entier :



$ greet --name Alice
Hello, Alice!





  
  
  Distribuer sur PyPI


Pour distribuer votre outil publiquement, créez un compte PyPI et suivez les étapes pour télécharger votre package :


Créez le package :



   python setup.py sdist bdist_wheel





Téléchargez le package :



   twine upload dist/*








  
  
  Meilleures pratiques pour la création de CLI




Fournissez des messages d'aide clairs : incluez toujours --help pour guider les utilisateurs.

Valider les entrées : utilisez la vérification de type et gérez les exceptions avec élégance.

Concevez des commandes intuitives : assurez-vous que votre structure de commandes est logique et facile à utiliser.

Testez avec des cas extrêmes : assurez-vous que votre outil CLI se comporte correctement même avec des entrées non valides.

Modularisez votre code : gardez votre logique de ligne de commande séparée de vos fonctionnalités principales pour faciliter les tests et la maintenance.






  
  
  Conclusion


Python fournit une excellente boîte à outils pour créer des applications d'interface de ligne de commande (CLI). Que vous utilisiez le module argparse intégré ou le clic plus riche en fonctionnalités, vous pouvez créer des outils puissants et conviviaux capables d'automatiser les flux de travail, de traiter les données et d'améliorer la productivité.

Maintenant que vous avez appris les bases et les fonctionnalités avancées de l'utilisation de la CLI en Python, il est temps de la mettre en pratique. Créez votre propre outil, partagez-le ou même distribuez-le dans le monde entier !




N'hésitez pas à nous contacter si vous avez des questions ou des suggestions :

• LinkedIn
• GitHub