Introducción
Contenido
UN Interfaz de línea de comandos (CLI) es una forma de interactuar con las computadoras mediante comandos textuales.
Muchas herramientas que no requieren GUI están escritas como herramientas / utilidades CLI. Aunque Python tiene incorporado argparse
módulo, existen otras bibliotecas con funciones similares.
Estas bibliotecas pueden ayudarnos a escribir secuencias de comandos CLI, proporcionando servicios como opciones de análisis y marcas para una funcionalidad CLI mucho más avanzada.
Este artículo analiza el Fuego de python biblioteca, escrita por Google Inc., una herramienta útil para crear CLI con código mínimo.
Forma general de aplicaciones CLI
Antes de empezar con el Fire
biblioteca intentemos comprender los conceptos básicos de los programas de interfaz de línea de comandos en general. Dependiendo del programa y comando, el patrón general de una CLI se puede resumir de la siguiente manera:
prompt command parameter1 parameter2 ... parameterN
- rápido es una secuencia de caracteres que indicaciones el usuario para ingresar un comando
- mando es el nombre del programa que el usuario está ejecutando (p. ej.
ls
) - parámetros son tokens opcionales que aumentan o modifican la salida del comando
Un programa CLI se ejecuta escribiendo el nombre del programa después de la prompt
aparece, en este caso el PS símbolo.
Aquí estamos usando el ls
comando que devuelve una lista de nombres de archivos en un directorio, siendo el directorio actual el predeterminado:
$ ls
README.md
python
Puede modificar el comportamiento o la salida de un programa de línea de comandos proporcionándole una lista de tokens o parámetros más conocidos como banderas. Probemos una bandera del ls
mando:
$ ls -l
-rwxrwxrwx 1 pandeytapan pandeytapan 10 Sep 23 18:29 README.md
drwxrwxrwx 1 pandeytapan pandeytapan 512 Sep 23 18:29 python
Como puede ver, después de pasar el -l
, obtenemos información adicional para cada entrada, como el propietario, el grupo y el tamaño del archivo.
Banderas que tienen un solo guion (-
) se denominan opciones cortas, mientras que aquellas con dos guiones (--
) se denominan opciones largas. Ambos tipos se pueden usar juntos en un solo comando, como en el siguiente ejemplo:
$ ls -l --time-style=full-iso
-rwxrwxrwx 1 pandeytapan pandeytapan 10 2020-09-23 18:29:25.501149000 +0530 README.md
drwxrwxrwx 1 pandeytapan pandeytapan 512 2020-09-23 18:29:25.506148600 +0530 python
La diferencia entre opciones cortas y largas:
- Las opciones cortas se pueden encadenar juntas
- Si queremos usar tanto el
-l
y-a
opciones cortas que simplemente escribimos-al
- Si queremos usar tanto el
- Las opciones cortas se indican con un solo carácter, mientras que las opciones largas tienen un nombre completo separado por guiones y no se pueden encadenar.
los --time-style
bandera funciona con el -l
marca y controla el formato de tiempo de visualización para una lista de directorios.
Una CLI proporciona una manera fácil para que el usuario configure y ejecute una aplicación desde la línea de comandos. La biblioteca Python Fire de Google facilita la adición de un componente de procesamiento CLI a cualquier script Python existente.
Veamos cómo hacer una aplicación de línea de comandos usando Python Fire.
Instalación
Sigamos e instalemos la biblioteca usando pip
:
$ pip install fire
Python Fire
funciona en cualquier objeto de Python, es decir, funciones, clases, diccionarios, listas, etc. Tratemos de comprender el uso de Python Fire
biblioteca a través de algunos ejemplos.
Generando una aplicación CLI con Python Fire
Hagamos un guión, digamos, fire_cli.py
y poner una función dentro de él:
def greet_mankind():
"""Greets you with Hello World"""
return 'Hello World'
Al ejecutar este programa en el shell de Python, el resultado es:
>>> from fire_cli import greet_mankind
>>> greet_mankind()
'Hello World'
>>>
Podemos convertir fácilmente este script en una aplicación CLI usando Python Fire:
import fire
def greet_mankind():
"""
Returns a textual message
"""
return 'Hello World'
if __name__ == '__main__':
fire.Fire()
los fire.Fire()
llamadas convierte el módulo es decir fire_cli.py
en una aplicación Fire CLI. Además, ha expuesto la greet_mankind()
funciona como comando, automáticamente.
Ahora podemos guardar y ejecutar el script anterior como CLI de la siguiente manera:
$ python fire_greet_mk_cli.py greet_mankind
Hello World
Como recordatorio, analicemos la llamada:
- PS es el aviso
- python es el intérprete de comandos
- fire_cli.py es el módulo que contiene el comando CLI
- saludar a la humanidad es el comando
Pasar argumentos a un comando
Creemos otra aplicación CLI que tome un nombre como parámetro y muestre un mensaje de saludo personalizado:
import fire
def greetings(name):
'''
Returns a greeting message
Parameters
----------
name : string
String that represents the addresses name
Returns
-------
string
greeting message concatenated with name
'''
return 'Hello %s' % name
if __name__ == '__main__':
fire.Fire()
Aquí, ahora tenemos una función que acepta una cadena: name
. Python Fire recoge esto automáticamente y si proporcionamos un argumento después de greetings
llamar, vinculará esa entrada a la name
parámetro. También hemos agregado un comentario como una especie de documentación para el --help
mando.
Así es como podemos ejecutar este comando desde la línea de comandos:
$ python fire_greet_cli.py greetings Robin
Hello Robin
Una aplicación Fire CLI puede usar --help
banderas para verificar la descripción del comando generada a partir de los documentos de Python:
python fire_greet_cli.py greetings --help
NAME
fire_greet_cli.py greetings - Returns a greeting message
SYNOPSIS
fire_greet_cli.py greetings NAME
DESCRIPTION
Returns a greetings message
POSITIONAL ARGUMENTS
NAME
String that represents the addresses name
NOTES
You can also use flags syntax for POSITIONAL ARGUMENTS
Establecer una función como punto de entrada
Con una ligera modificación podemos controlar la exposición del greetings()
función a la línea de comandos y configurarlo como el punto de entrada predeterminado:
import fire
def greetings(name):
'''
Returns a greeting message
:param name: string argument
:return: greeting message appended with name
'''
return 'Hello %s' % name
if __name__ == '__main__':
fire.Fire(greetings)
Así es como ejecutaremos el comando ahora:
$ python fire_greet_cli.py Robin
Hello Robin
Entonces esta vez ya no necesitamos llamar al comando como lo hemos definido greetings
implícitamente como un punto de entrada usando Fire()
. Una cosa a tener en cuenta aquí es que con esta versión, solo podemos pasar un único argumento :
$ python fire_greet_cli.py Robin Hood
ERROR: Could not consume arg: Hood
...
$ python fire_greet_cli.py Robin
Hello Robin
Análisis de argumentos
La biblioteca de Fire también funciona con clases. Definamos una clase CustomSequence
que genera y devuelve una lista de números entre start
y end
:
import fire
class CustomSequence:
'''Class that generates a sequence of numbers'''
def __init__(self, offset=1):
'''
Parameters
----------
offset : int, optional
Number controlling the difference between two generated values
'''
self.offset = offset
def generate(self, start, stop):
'''
Generates the sequence of numbers
Parameters
----------
start : int
Number that represents the elements lower bound
stop : int
Number that represents the elements upper bound
Returns
-------
string
a string that represents the generated sequence
'''
return ' '.join(str(item) for item in range(start, stop, self.offset))
if __name__ == '__main__':
fire.Fire(CustomSequence)
Así es como generamos una secuencia usando esta utilidad de línea de comandos:
$ python fire_gen_cli.py generate 1 10
1 2 3 4 5 6 7 8 9
Usamos una clase en lugar de una función porque, a diferencia de las funciones, si queremos pasar un argumento al constructor, siempre debe representarse como una bandera de línea de comando con guiones dobles (p. Ej. --offset=2
).
Por lo tanto, nuestra aplicación CLI admite un argumento opcional --offset
que se pasará al constructor de la clase. Esto modifica la salida controlando la diferencia entre dos valores generados consecutivamente:
Aquí está la salida con un valor de compensación de 2:
$ python fire_gen_cli.py generate 1 10 --offset=2
1 3 5 7 9
Los argumentos del constructor siempre se pasan usando la sintaxis de la bandera, mientras que los argumentos a otros métodos o funciones se pasan posicionalmente o por nombre:
$ python fire_gen_cli.py generate --start=10 --stop=20
10 11 12 13 14 15 16 17 18 19
$ python fire_gen_cli.py generate 10 20
10 11 12 13 14 15 16 17 18 19
$ python fire_gen_cli.py generate --start=10 --stop=20 --offset=2
10 12 14 16 18
Podemos comprobar el uso delgenerate
comando usando el --help
bandera. Esto le dará la información de uso para la CLI:
$ python fire_gen_cli.py generate --help
INFO: Showing help with the command 'fire_gen_cli.py generate -- --help'.
NAME
fire_gen_cli.py generate - Generates the sequence of numbers
SYNOPSIS
fire_gen_cli.py generate START STOP
DESCRIPTION
Generates the sequence of numbers
POSITIONAL ARGUMENTS
START
Number that represents the first value for the sequence
STOP
Number that represents the ending value for the sequence
NOTES
You can also use flags syntax for POSITIONAL ARGUMENTS
Utilizando --help
con el módulo nos da su información de uso:
$ python fire_gen_cli.py --help
INFO: Showing help with the command 'fire_gen_cli.py -- --help'.
NAME
fire_gen_cli.py - Class that generates a sequence of numbers
SYNOPSIS
fire_gen_cli.py <flags>
DESCRIPTION
Class that generates a sequence of numbers
FLAGS
--offset=OFFSET
Banderas de fuego
Fire CLI viene con muchos indicadores integrados. Ya hemos visto --help
Sin embargo, otra bandera útil es --interactive
. El uso de esta bandera nos pone en modo Python REPL, con el módulo ya definido.
Esto es bastante útil para probar comandos:
$ python fire_greet_cli.py -- --interactive
Fire is starting a Python REPL with the following objects:
Modules: fire
Objects: component, fire_greet_cli.py, greetings, result, trace
Python 3.7.8 (tags/v3.7.8:4b47a5b6ba, Jun 28 2020, 08:53:46) [MSC v.1916 64 bit (AMD64)]
Type 'copyright', 'credits' or 'license' for more information
IPython 7.16.1 -- An enhanced Interactive Python. Type '?' for help.
In [1]: greetings("Robin")
Out[1]: 'Hello Robin'
Tenga en cuenta que las banderas de fuego deben separarse de otras opciones con dos guiones (--
), así que si queremos usar ambos --help
y --interactive
banderas en un comando, se vería así:
$ python fire_greet_cli.py -- --help --interactive
Conclusión
La biblioteca Python Fire de Google es una forma rápida y fácil de generar interfaces de línea de comandos (CLI) para casi cualquier objeto Python.
En este artículo, hemos repasado cómo instalar Python Fire, así como también cómo generar interfaces de línea de comandos simples.