Recherche de site Web

Tutoriel Python Typer : Créer des CLI avec Python en quelques minutes

Apprenez à créer des CLI avec Python à l'aide de Typer en quelques étapes simples.

Dans ce didacticiel, nous allons créer une interface de ligne de commande (CLI) à l'aide de Typer, une bibliothèque Python qui rend la création de CLI rapide et simple. Typer exploite également les astuces de type de Python.

Ce didacticiel vous expliquera comment créer une CLI pour un suivi de planification. Plus précisément, nous apprendrons comment :

  • Configurer Typer
  • Ajouter des commandes
  • Gérez correctement les tâches, le temps et la priorité : les types d'entrée et de données

Commençons !

Étape 1 : Installer Typer

Commençons par installer Typer :

$ pip3 install typer

L'installation de Typer installe automatiquement toutes les dépendances requises, ce qui facilite la fonctionnalité de l'interface de ligne de commande. Veuillez installer Typer dans un environnement virtuel pour le projet.

Voici le référentiel GitHub pour ce projet simple.

Étape 2 : Créer la CLI de base

Commençons par créer une CLI simple qui peut ajouter une tâche à un planning avec le format d'heure correct.

Créez un fichier Python nommé schedule_tracker.py.

Importez les bibliothèques et modules requis. L'instance typer.Typer() (app) gère les commandes CLI.

import typer
from datetime import datetime
import json
from typing import List

app = typer.Typer()

Nous définissons quelques fonctions d'assistance à partir desquelles charger le planning et l'enregistrer dans un fichier JSON :

SCHEDULE_FILE = "schedule.json"

def load_schedule() -> List[dict]:
    try:
        with open(SCHEDULE_FILE, "r") as f:
            return json.load(f)
    except (FileNotFoundError, json.JSONDecodeError):
        return []

def save_schedule(schedule: List[dict]):
    with open(SCHEDULE_FILE, "w") as f:
        json.dump(schedule, f, default=str, indent=4)

Parce que nous avons une heure associée à chaque tâche, créons une fonction d'assistance qui analyse la chaîne en un objet time valide :

def parse_time(t: str) -> datetime.time:
    try:
        return datetime.strptime(t, "%H:%M").time()
    except ValueError:
        typer.echo("Invalid time format. Please use HH:MM.")
        raise typer.Exit()

Créez la commande de base add_task. La tâche (une description de la tâche), l'heure et la priorité définissent chaque élément de tâche :

@app.command()
def add_task(
	task: str,
	time: str = typer.Option(..., help="Time in HH:MM format"),
	priority: int = typer.Option(1, help="Priority of the task")
):
    schedule = load_schedule()
    task_time = parse_time(time)
    schedule.append({"task": task, "time": task_time.strftime("%H:%M"), "priority": priority})
    save_schedule(schedule)
    typer.echo(f"Task '{task}' added at {task_time.strftime('%H:%M')} with priority {priority}")

if __name__ == "__main__":
	app()

Étape 3 : Exécutez la CLI

Exécutez maintenant schedule_tracker.py pour ajouter des tâches comme ceci :

$ python3 schedule_tracker.py add-task "Team meeting" --time "14:00" --priority 2

Quelles sorties :

Task 'Team meeting' added at 14:00 with priority 2

Vous disposez désormais d’une CLI fonctionnelle qui accepte les tâches avec une durée et une priorité associées !

Étape 4 : ajouter plus de commandes

Ajoutons plus de fonctionnalités à notre outil de suivi du planning, telles que l'affichage et la suppression de tâches.

Tout d’abord, ajoutez une commande pour afficher les tâches triées par heure :

@app.command()
def list_tasks():
    """List all scheduled tasks."""
    schedule = load_schedule()
    if not schedule:
        typer.echo("No tasks found.")
        return
    for task in sorted(schedule, key=lambda x: x["time"]):
        @app.command()
        print(f"Task {i}: {task['task']}")
        print(f"  Time: {task['time']}")
        print(f"  Priority: {task['priority']}")
        print("-" * 40)  # Add a separator line for better readability

Vous pouvez également modifier cette fonction selon vos besoins pour trier les tâches par priorité.

Ajoutons également une commande pour supprimer les tâches par leur numéro d'index :

@appcommand()
def remove_task(task_number: int):
    """Remove a task by its number."""
    schedule = load_schedule()
    if 0 < task_number <= len(schedule):
        removed_task = schedule.pop(task_number - 1)
        save_schedule(schedule)  # Save the updated schedule
        typer.echo(f"Removed task '{removed_task['task']}' scheduled at {removed_task['time']}") 
    else: 
        typer.echo(f"Invalid task number. Choose a number between 1 and {len(schedule)}.")

Étape 5 : testez la CLI améliorée

Maintenant, testez les commandes suivantes.

Ajoutez plusieurs tâches :

$ python3 schedule_tracker.py add-task "Code review" --time "10:30" --priority 1
$ python3 schedule_tracker.py add-task "Client meeting" --time "12:00" --priority 3

Ce faisant, vous verrez :

Task 'Code review' added at 10:30 with priority 1
Task 'Client meeting' added at 12:00 with priority 3

Afficher toutes les tâches :

$ python3 schedule_tracker.py list-tasks

L'exécution de cette commande génère :

Task 0: Code review
  Time: 10:30
  Priority: 1
----------------------------------------
Task 1: Client meeting
  Time: 12:00
  Priority: 3
----------------------------------------
Task 2: Team meeting
  Time: 14:00
  Priority: 2
----------------------------------------

Supprimer une tâche :

$ python3 schedule_tracker.py remove-task 1

Cela produit :

Removed task 'Team meeting' scheduled at 14:00

Consultez la liste des tâches mise à jour :

$ python3 schedule_tracker.py list-tasks

Nous devrions maintenant voir le résultat suivant :

Task 0: Code review
  Time: 10:30
  Priority: 1
----------------------------------------
Task 1: Client meeting
  Time: 12:00
  Priority: 3
----------------------------------------

Conclusion

C'est tout pour ce tutoriel. Comme nous l'avons vu, avec Typer, vous pouvez créer des CLI simples mais puissantes en quelques minutes seulement. Dans ce didacticiel, nous avons créé un outil de suivi des plannings qui gère efficacement les tâches et la validation des entrées de temps.

Vous pouvez maintenant améliorer la version que nous avons construite. Vous pouvez étendre ce projet en ajoutant plus de fonctionnalités telles que des tâches récurrentes, des rappels ou l'exportation du planning. Ou vous pouvez essayer de créer une application similaire pour suivre les dépenses.

Bon codage !