Tutorial de Python Typer: cree CLI con Python en minutos

Aprenda a crear CLI con Python usando Typer en unos sencillos pasos.

En este tutorial, crearemos una interfaz de línea de comandos (CLI) utilizando Typer, una biblioteca de Python que hace que la creación de CLI sea rápida y sencilla. Typer también aprovecha las sugerencias de tipo de Python.

Este tutorial le mostrará cómo crear una CLI para un rastreador de programación. Específicamente, aprenderemos cómo:

Configurar Typer
Agregar comandos
Maneje la tarea, el tiempo y la prioridad: tipos de entrada y datos correctamente

¡Empecemos!

Paso 1: instalar Typer

Primero, instalemos Typer:

$ pip3 install typer

La instalación de Typer instala automáticamente todas las dependencias requeridas, lo que facilita la funcionalidad de la interfaz de línea de comandos. Instale Typer en un entorno virtual para el proyecto.

Aquí está el repositorio de GitHub para este sencillo proyecto.

Paso 2: cree la CLI básica

Comencemos creando una CLI simple que pueda agregar una tarea a una programación con el formato de hora correcto.

Cree un archivo Python llamado schedule_tracker.py.

Importe las bibliotecas y módulos necesarios. La instancia typer.Typer() (app) administra los comandos CLI.

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

app = typer.Typer()

Definimos algunas funciones auxiliares para cargar el programa y guardarlo en un archivo 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)

Debido a que tenemos un tiempo asociado con cada tarea, creemos una función auxiliar que analice la cadena en un objeto de tiempo válido:

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()

Cree el comando básico add_task. La tarea (una descripción de la tarea), el tiempo y la prioridad definen cada elemento de la tarea:

@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()

Paso 3: ejecute la CLI

Ahora ejecute schedule_tracker.py para agregar tareas como esta:

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

Qué salidas:

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

¡Ahora tiene una CLI funcional que acepta tareas con tiempo y prioridad asociados!

Paso 4: agregue más comandos

Agreguemos más funciones a nuestro rastreador de programación, como ver y eliminar tareas.

Primero, agregue un comando para ver las tareas ordenadas por tiempo:

@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

También puede modificar esta función según sea necesario para ordenar las tareas por prioridad.

Agreguemos también un comando para eliminar tareas por su número de índice:

@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)}.")

Paso 5: Pruebe la CLI mejorada

Ahora, pruebe los siguientes comandos.

Agregue múltiples tareas:

$ 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

Al hacerlo, verá:

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

Ver todas las tareas:

$ python3 schedule_tracker.py list-tasks

Al ejecutar este comando se genera:

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
----------------------------------------

Eliminar una tarea:

$ python3 schedule_tracker.py remove-task 1

Esto produce:

Removed task 'Team meeting' scheduled at 14:00

Ver la lista de tareas actualizada:

$ python3 schedule_tracker.py list-tasks

Ahora deberíamos ver el siguiente resultado:

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

Concluyendo

Eso es todo por este tutorial. Como se ve, con Typer, puede crear CLI simples pero potentes en solo minutos. En este tutorial, creamos un rastreador de programación que maneja tareas y validación de entrada de tiempo de manera eficiente.

Ahora puede mejorar la versión que hemos creado. Puede ampliar este proyecto agregando más funciones como tareas recurrentes, recordatorios o exportando el cronograma. O puede intentar crear una aplicación similar para realizar un seguimiento de los gastos.

¡Feliz codificación!