Introducción

Python es ampliamente conocido por su versatilidad y facilidad de uso, especialmente cuando se crean aplicaciones de interfaz de línea de comandos (CLI). Ya sea que desee automatizar tareas mundanas, crear herramientas para desarrolladores o crear scripts flexibles, el rico ecosistema de Python ofrece varias bibliotecas para manejar CLI de manera eficiente.

En esta publicación de blog, profundizaremos en el trabajo con CLI en Python y cubriremos lo siguiente:

• ¿Por qué crear una CLI?
• Módulos de Python para crear CLI
• Los conceptos básicos de los argumentos de la línea de comandos
• Funciones avanzadas usando argparse
• Creación de herramientas CLI con un clic
• Manejo de errores en herramientas CLI
• Empaquetado de herramientas CLI para distribución

Al final de esta publicación, estará equipado para crear aplicaciones de línea de comandos sólidas y fáciles de usar.

¿Por qué crear una CLI?

Las CLI se utilizan ampliamente en la administración de sistemas, el procesamiento de datos y el desarrollo de software porque ofrecen:

1. Automatización: Realiza scripts de tareas repetitivas para ahorrar tiempo y reducir errores.
2. Simplicidad: ejecuta comandos complejos con unas pocas pulsaciones de teclas.
3. Portabilidad: una herramienta CLI bien diseñada se puede utilizar en cualquier máquina sin una GUI.
4. Herramientas de desarrollo: Muchas herramientas de desarrollo (como git, npm y pip) están basadas en CLI.

Módulos de Python para desarrollo CLI

Python ofrece varias bibliotecas para crear herramientas CLI:

1. sys.argv: acceso directo a argumentos de línea de comandos, adecuado para scripts pequeños y simples.
2. argparse: módulo integrado para manejar argumentos de línea de comandos con generación automática de ayuda.
3. click: una biblioteca potente y flexible para crear aplicaciones CLI complejas.
4. typer: una biblioteca moderna construida sobre el clic, que utiliza sugerencias de tipo Python para facilitar su uso.

Trabajando con sys.argv

sys.argv es una forma básica de acceder a los argumentos de la línea de comandos. Almacena los argumentos de la línea de comandos como una lista, donde el primer elemento es siempre el nombre del script.

import sys

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

Ejecutando el script:

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

Limitaciones de sys.argv:

• Sin verificación de tipo: todas las entradas se tratan como cadenas.
• Sin mensaje de ayuda integrado: debe validar manualmente las entradas y mostrar información de uso.

Construyendo CLI con argparse

El módulo argparse es la biblioteca estándar de Python para crear CLI. Ofrece más control que sys.argv y genera automáticamente mensajes de ayuda y manejo de errores.

Ejemplo básico:

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}!")

Ejecutando el script:

$ python script.py Alice
Hello, Alice!

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

Características clave de argparse:

1. Argumentos posicionales y opcionales: Defina fácilmente los parámetros requeridos y opcionales.
2. Comprobación de tipo: asegúrese de que el usuario proporcione el tipo de datos correcto.
3. Opciones: restringe las entradas a valores específicos usando el parámetro de opciones.
4. Mensajes de ayuda: genera ayuda automáticamente con el indicador -h o --help.

Ejemplo con verificación de tipos y opciones:

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

Ejecutando el script:

$ python script.py Alice 30 --format json

Herramientas CLI avanzadas con clic

click es una biblioteca más avanzada para crear interfaces de línea de comandos. Proporciona un enfoque basado en decoradores para definir comandos, subcomandos y opciones.

¿Por qué utilizar el clic?

• Mejor legibilidad: una sintaxis más pitónica basada en decoradores.
• Validación automática de argumentos: garantiza que los argumentos se validen correctamente.
• Componentes reutilizables: los comandos, opciones y argumentos se pueden reutilizar fácilmente en diferentes partes de tu aplicación.

Ejemplo básico usando clic:

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

Ejecutando el script:

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

Subcomandos con clic:

Puedes crear herramientas CLI más complejas con múltiples subcomandos.

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

Ejecutando el script:

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

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

Manejo de errores en herramientas CLI

No importa qué biblioteca utilices, el manejo de errores es crucial para brindar una experiencia de usuario fluida.

Ejemplo en argparse:

Si falta un argumento requerido, argparse arrojará un error y mostrará instrucciones de uso:

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

Manejo de errores al hacer clic:

Al hacer clic, puedes generar excepciones personalizadas y manejar errores elegantemente usando decoradores.

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





  
  
  Combinando argparse y hacer clic con otras bibliotecas


Para ampliar la funcionalidad CLI, puede combinar argparse o hacer clic con otras bibliotecas como sistema operativo, subproceso o incluso bibliotecas personalizadas.


  
  
  Ejemplo: Combinando argparse con 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.")




Ejecutando el script:


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






  
  
  Embalaje de su herramienta CLI


Para distribuir su herramienta CLI, puede empaquetarla usando herramientas de configuración y hacerla accesible globalmente en cualquier sistema.


  
  
  Paso 1: Crear un archivo 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
    ''',
)





  
  
  Paso 2: Instale su CLI localmente




$ pip install --editable .




Ahora, el comando de saludo está disponible globalmente:


$ greet --name Alice
Hello, Alice!





  
  
  Distribuir en PyPI


Para distribuir su herramienta públicamente, cree una cuenta PyPI y siga los pasos para cargar su paquete:

Construye el paquete:

   python setup.py sdist bdist_wheel




Sube el paquete:

   twine upload dist/*






  
  
  Mejores prácticas para crear CLI



Proporcione mensajes de ayuda claros: incluya siempre ayuda para guiar a los usuarios.

Validar entradas: utilice la verificación de tipos y maneje las excepciones con elegancia.

Diseñe comandos intuitivos: asegúrese de que su estructura de comandos sea lógica y fácil de usar.

Prueba con casos extremos: asegúrese de que su herramienta CLI se comporte correctamente incluso con entradas no válidas.

Modulariza tu código: mantén tu lógica de línea de comandos separada de tu funcionalidad principal para facilitar las pruebas y el mantenimiento.

  
  
  Conclusión


Python proporciona un excelente conjunto de herramientas para crear aplicaciones de interfaz de línea de comandos (CLI). Ya sea que esté utilizando el módulo argparse integrado o el clic con más funciones, puede crear herramientas poderosas y fáciles de usar que pueden automatizar flujos de trabajo, procesar datos y mejorar la productividad.

Ahora que ha aprendido los conceptos básicos y las funciones avanzadas para trabajar con CLI en Python, es hora de ponerlo en práctica. ¡Construya su propia herramienta, compártala o incluso distribúyala globalmente!


No dudes en comunicarnos con nosotros si tienes preguntas o sugerencias:

• LinkedIn
• GitHub