Creación de utilidades de línea de comandos con argparse de Python

C

Introducción

La mayor parte del software de cara al usuario viene con una interfaz agradable a la vista o mediante una página web decorada. En otras ocasiones, un programa puede ser tan pequeño que no garantiza una interfaz gráfica de usuario completa o una aplicación web para exponer su funcionalidad al usuario final.

En estos casos, podemos crear programas a los que se pueda acceder mediante una interfaz de línea de comandos o CLI.

En esta publicación, exploraremos Python argparse y utilícelo para crear una herramienta de línea de comandos sencilla que nos ayude a acortar las URL con rapidez.

Interfaz de línea de comandos

Una interfaz de línea de comandos es una interfaz de usuario basada en texto que proporciona un medio para interactuar con una computadora a través de comandos textuales. El programa que facilita esta interacción al exponer la interfaz se conoce como intérprete de línea de comandos o shell.

Toma comandos en forma de entrada de texto, ejecuta programas basados ​​en la entrada proporcionada y luego muestra la salida en la interfaz. Hay muchas Shells disponibles, siendo las primeras las más populares las Cáscara de Bourne y C shell para sistemas basados ​​en Unix. los Bourne Again Shell (también conocido como bash) es una extensión muy popular de Bourne Shell, junto con Shell de Korn (ksh).

También vale la pena señalar que las CLI, al igual que otros programas, requieren cuentas de usuario para trabajar con ellas. El sistema impone permisos a estos usuarios para ayudar a controlar el nivel de acceso y el límite de lo que un usuario puede lograr con el sistema. Esta distinción es necesaria ya que el shell es una interfaz entre el usuario y el núcleo del sistema operativo que controla todas las operaciones de la computadora. El acceso a esta funcionalidad debe restringirse para evitar el uso malintencionado de la interfaz de línea de comandos.

Las CLI ofrecen un mensaje, que suele ser un signo de dólar ($) que indica que puede ingresar su comando. Sin embargo, este mensaje también indica que el comando ingresado se ejecutará sin acceso de root.

Cuando se concede acceso de raíz al usuario actual que interactúa con la CLI, el mensaje cambia a un signo de almohadilla (#).

Si bien las interfaces gráficas de usuario (GUI) son más fáciles de aprender y visualmente más intuitivas, las CLI permiten a los usuarios interactuar con el software usando solo un teclado, lo que puede resultar en un rendimiento más rápido. Las CLI también consumen menos recursos informáticos en comparación con las GUI, lo que las hace más ligeras y rápidas.

Scripting

La mayoría de los intérpretes de línea de comandos se envían con algunos comandos básicos que pueden invocarse a través de la interfaz de línea de comandos para realizar tareas específicas. Algunos comunes incluyen:

  • uptime: Indica cuánto tiempo ha estado encendida la computadora
  • date: Devuelve la fecha y hora actuales.
  • ls: Devuelve una lista de todos los archivos y carpetas de un directorio.
  • cd: Se utiliza para pasar de un directorio a otro
  • pwd: Se utiliza para mostrar el directorio de trabajo actual
  • man: Se utiliza para mostrar el manual o las instrucciones de cualquier comando.
  • touch: Se utiliza para crear archivos nuevos y vacíos
  • mkdir: Se utiliza para crear nuevos directorios

Un script de shell es un programa diseñado para ser ejecutado por un intérprete de línea de comandos. Contiene una serie de comandos, como los enumerados anteriormente, junto con variables y condiciones que instruyen al shell sobre qué tarea o tareas realizar.

A través de los scripts de shell, un usuario puede ejecutar múltiples comandos en rápida sucesión sin la necesidad de recordarlos todos. Se utilizan principalmente para lograr operaciones repetitivas sin la entrada repetitiva de comandos, por lo tanto, reduciendo el esfuerzo requerido por el usuario final.

Podemos escribir scripts de shell que constan de los comandos de shell que se ejecutarán, pero también podemos ejecutar otros lenguajes de alto nivel, como Python y JavaScript.

¿Qué es argparse?

Un script de shell de Python es simplemente un programa Python normal que ejecuta el intérprete de línea de comandos. Al ejecutar un script de shell, los argumentos se pasan a nuestro script a través de sys.argv. Esta variable es una lista de los argumentos pasados ​​a nuestro programa, incluido el nombre del script, que también es el primer argumento.

Normalmente, podemos escribir un script simple que no requiera argumentos adicionales, como un script simple para mostrar la fecha actual. Sin embargo, esto limitará la funcionalidad que podemos ofrecer. Para hacer nuestros scripts más versátiles y ampliar el alcance de su uso, tenemos que facilitar la personalización a través de argumentos que brinden al usuario más control y opciones en términos de funcionalidad.

los argparse El módulo nos ayuda a analizar los argumentos pasados ​​con nuestro script y procesarlos de una manera más conveniente. También agrega funciones de personalización como nombrar nuestro programa y agregar descripciones de una manera más sencilla.

argparse también nos proporciona un medio para personalizar las instrucciones de uso de nuestro script e indicar qué argumentos son necesarios y cuáles son opcionales. Para explorar todas estas características y más, crearemos nuestra propia utilidad CLI de Python en la siguiente sección.

Aplicación de demostración

Actualmente, si queremos acortar una URL, necesitaremos iniciar un navegador y navegar a un sitio de acortamiento de URL para realizar la tarea. Nuestro objetivo es acelerar y mejorar este proceso de acortamiento de URL a través de un script que podemos iniciar en cualquier momento en nuestro terminal. Solo tendremos que pasar las URL que necesitamos acortar como argumentos y recibir las URL acortadas como respuesta.

Para esta demostración, usaremos Shorte.st como nuestro proveedor ya que su API es simple y directa.

Después de crear una cuenta, podemos ir a la sección Herramientas de enlace y seleccionar API de desarrolladores. Aquí encontraremos nuestro token de acceso y la URL que usará nuestro script para acortar nuestras URL.

Una vez que el usuario proporciona una URL a nuestra utilidad de línea de comandos para que se acorte, enviaremos la URL al punto final de la API de Shorte.st junto con nuestro token de acceso. La respuesta será nuestra URL abreviada y un mensaje de estado.

Comencemos por crear un entorno virtual e instalar el módulo de solicitudes, que usaremos para enviar solicitudes HTTP a la API:

$ mkdir pyshortener && cd pyshortener
$ virtualenv --python=python3 env --no-site-packages
$ source env/bin/activate
$ pip install requests

En la primera línea anterior hemos combinado dos comandos en uno usando el doble ampersand (&&). Esto nos permite ejecutar los comandos en secuencia, a menos que el primer comando falle, lo que evita que se ejecute el segundo comando.

Después de crear nuestro entorno virtual y activarlo, instalamos nuestra dependencia de Python.

Para esta demostración, primero crearemos nuestra función de acortamiento y luego ajustaremos su funcionalidad usando argparse en el guión final:

import requests
from requests.exceptions import ConnectionError
import json

def shorten_url(url):
    try:
        response = requests.put("https://api.shorte.st/v1/data/url",
                                {"urlToShorten": url},
                                headers={"public-api-token": "[MY-API-TOKEN]"})

        api_response = json.loads(response.content)

        return {"status": api_response['status'],
                "shortenedUrl": api_response['shortenedUrl'],
                "message": "URL shortened successfully"}

    except ConnectionError:
        return {"status": "error",
                "shortenedUrl": None,
                "message": "Please ensure you are connected to the internet and try again."}

shorten_url(www.Pharos.sh.com)

Nuestra función toma una URL y la envía a la API de Shorte.st y devuelve la URL abreviada. Acortemos www.Pharos.sh.com ejecutando nuestro script:

$ python pyshortener.py
{'status': 'ok', 'shortenedUrl': 'http://gestyy.com/w6ph2J', 'message': 'URL shortened successfully'}

Como podemos ver, nuestra función funciona pero la salida es menos que ideal. También tenemos que codificar la URL en el propio script, lo que nos da una entrada y salida fija.

Vamos a llevar esto un paso más allá y permitir que los usuarios pasen la URL como argumento cuando ejecuten el script. Para hacer esto, ahora presentaremos argparse para ayudarnos a analizar los argumentos proporcionados por el usuario:

import requests
from requests.exceptions import ConnectionError
import json
import argparse # Add the argparse import

def shorten_url(url):
    # Code stays the same...

# Create a parser
parser = argparse.ArgumentParser(description='Shorten URLs on the terminal')

# Add argument
parser.add_argument('--url', default="google.com", help="The URL to be shortened")
args = vars(parser.parse_args())
print(args)

En esta versión del script, no llamamos shorten_url, sino que imprima los argumentos capturados y analizados por argparse.

Empezamos creando un ArgumentParser objeto usando argparse, que contendrá toda la información necesaria para transformar los argumentos pasados ​​en tipos de datos de Python con los que podamos trabajar.

Después de crear el analizador, ahora podemos agregar argumentos usando parser.add_argument(). Esta función permite especificar la siguiente información sobre nuestros argumentos:

  • El primer argumento es un nombre o una bandera que se usa para identificar nuestros argumentos. Los argumentos opcionales se identifican por - prefijo, en nuestro caso --url es un argumento opcional.
  • los default La opción permite especificar un valor predeterminado cuando el usuario no ha proporcionado el argumento.
  • los help La opción describe brevemente cuál es el argumento.
  • También podemos utilizar el choice opción para especificar valores permitidos para un argumento, como sí y no.
  • A través de un type También podemos especificar el tipo al que se convertirá nuestro comando, por ejemplo, convertir argumentos en números enteros.

Cuando ejecutamos nuestro script sin proporcionar ningún argumento, la URL predeterminada es “google.com”, tal como lo configuramos en el add_argument método:

$ python pyshortener.py
{'url': 'google.com'}

Ahora cuando pasamos www.Pharos.sh.com utilizando el --url bandera, se establece como el valor de la url llave:

$ python pyshortener.py --url www.Pharos.sh.com
{'url': 'www.Pharos.sh.com'}

Ahora podemos recibir la URL de un usuario a través de la línea de comando y acortarla modificando nuestro script:

if args.get('url'):
   print(shorten_url(args['url']))

Cuando lo ejecutamos y pasamos una URL, deberíamos recibir el resultado de la API Shorte.st:

$ python pyshortener.py --url Pharos.sh.com
{'status': 'ok', 'shortenedUrl': 'http://gestyy.com/w6pk2R', 'message': 'URL shortened successfully'}

Aunque nuestra salida no es tan amigable como nos gustaría, así que creemos una función para formatear nuestra salida de una manera más deseable:

def handle_output(result):
   """ Function to format and print the output
   """
   if result["status"] == "ok":
       print(f"{result['message']}. Your shortened URL is:n"
             f"t{result['shortenedUrl']}")
   elif result["status"] == "error":
       print(f"{result['message']}")

# Receive and process the argument
args = vars(parser.parse_args())

if args.get('url'):
   result = shorten_url(args['url'])
   handle_output(result)

Cuando ejecutamos nuestro script una vez más:

$ python pyshortener.py --url www.Pharos.sh.com
URL shortened successfully. Your shortened URL is:
        http://gestyy.com/w6pk2R

Nuestra salida ahora es más fácil de usar debido a la adición de handle_output() función. Para ver como argparse ha generado el texto de ayuda para nuestro script, podemos ejecutar nuestro script con el -h bandera para mostrar el texto de ayuda de la siguiente manera:

$ python pyshortener.py -h
usage: pyshortener.py [-h] [--url URL]

Shorten URLs on the terminal

optional arguments:
  -h, --help  show this help message and exit
  --url URL   The URL to be shortened

Conclusión

Hemos creado un script de shell usando Python para ayudarnos a acortar las URL rápidamente en la terminal. Hemos utilizado el argparse módulo para analizar los argumentos que se pasan a nuestro script e incluso definen un valor predeterminado en caso de que se proporcione el argumento.

Nuestro script ahora también tiene un hermoso mensaje de ayuda que se puede mostrar usando el -h bandera que fue generada por el argparse módulo, lo que significa que no tuvimos que escribirlo manualmente.

El siguiente paso sería mejorar nuestro script para aceptar una lista de URL o leer URL de un archivo de texto para facilitar el acortamiento por lotes de URL.

Se puede encontrar el código fuente del script en este proyecto. aquí en Github.

About the author

Ramiro de la Vega

Bienvenido a Pharos.sh

Soy Ramiro de la Vega, Estadounidense con raíces Españolas. Empecé a programar hace casi 20 años cuando era muy jovencito.

Espero que en mi web encuentres la inspiración y ayuda que necesitas para adentrarte en el fantástico mundo de la programación y conseguir tus objetivos por difíciles que sean.

Add comment

Sobre mi

Últimos Post

Etiquetas

Esta web utiliza cookies propias para su correcto funcionamiento. Al hacer clic en el botón Aceptar, aceptas el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Más información
Privacidad