cómo hacer una interfaz de línea de comandos o un intérprete en python

Question

chicos. He visto algunas preguntas CLI aquí, pero aún quiero hacer esta pregunta para obtener respuestas más detalladas.

Ya he desarrollado class1.py, class2.py, etc. con funciones implementadas dentro de cada clase. p.ej. Operator.py tiene funciones add, less, time, devide. ¿Cómo puedo construir una interfaz de línea de comando para estas clases?

también para este CLI, ¿es un bucle infinito dentro del main() para la interacción?

Y cómo puede la CLI dar algunos comentarios, como sugerir al usuario para la próxima operación o ingresar el comando correcto o escribir --help y verificar todos los comandos disponibles. como las conchas de Bash.

también parece que hay un módulo optparse de python. ¿hay algunas muestras buenas, completas o de alta calidad que muestren cómo se construye una CLI? Me gustaría aprovechar esta oportunidad para aprender a escribir un programa de CLI.

Lo que quiero es: Ya he desarrollado varias clases, y también una GUI para llamar a los métodos de estas clases. Ahora quiero tener una CLI, como la GUI, para usar estas clases. p.ej. Tengo clases como CDContainer (con método como addCD, removeCD, etc.), CD (con métodos como play, stop, pause), y tengo una GUI que podría interactuar. Ahora quiero tener una CLI, que bajo el bash, podría ejecutar esta CLI y llamar a los comandos createCDContainer, addCD, removeCD.

Si uso cmd

class CDContainerCLI(cmd.Cmd): 

    def do_CDContainer(self, line): 
     print "create CD container" 

    def do_addcd(self, line): 
     print "add cd into the container" 

¿Cómo añado algunas opciones aquí? por ejemplo, quiero addcd --track 3 --cdname thriller Creo que "--track 3 --cdname thriller" son los 4 argumentos para la función addcd. cómo implementar eso?

Answer 1

Derive de cmd.Cmd, anulando los diversos métodos según sea necesario.

Answer 2

utilizar el módulo cmd:

• Referencia: Custom (interactive) shell with Python

Otros paquetes

También puede utilizar varios módulos alojados en PyPI que se construye en la parte superior del módulo cmd

• http://pypi.python.org/pypi/Custom%20Interactive%20Console/1.0

Answer 3

StackOverflow - How to write a shell in Python

Answer 4

no estoy seguro de lo que estás buscando: parece que quiere construir un shell interactivo, pero también se mencionan optparse, que está diseñado para simplificar la creación de una interfaz de módulo que se puede ejecutar desde el shell del sistema en lugar de proporcionar un shell en sí mismo.

Parece que desea que su módulo implemente su propio shell interactivo, pero quizás también quiera tener algunos comandos accesibles desde la línea de comando, p.llamando al your_script the_command --argument value --other-argument directamente desde bash o lo que sea. Este es el tipo de cosa que optparse está destinado a proporcionar, pero ha quedado en desuso en favor de argparse. argparse se encuentra en la biblioteca estándar de Python 2.7 y puede instalarse de manera estándar (por ejemplo, como una dependencia de su módulo, o mediante una instalación por separado a través de PyPI, etc.) para las Pythons más antiguas.

argparse hace que sea relativamente sencillo vincular determinadas opciones o subcomandos a los puntos de entrada (es decir, llamadas a funciones) en su código. La documentación es bastante detallada, y vale la pena una lectura a fondo si es probable que desee hacer algunas de esas interfaces. Para un uso avanzado, puede hacer algunas cosas interesantes y hacer que su código sea un poco más manejable, creando un custom action.

Answer 5

creo que lo que está pidiendo es cómo tratar fácilmente con argumentos opcionales dentro la consola interactiva, por lo que cuando se utiliza el programa que se verá algo como esto:

$ myprogram 
(Cmd) addcd --track 3 --cdname thriller 

Así miprograma corriendo abre su propio símbolo del sistema, al cual comandos como addcd pueden ser emitidos, junto con argumentos opcionales, y luego procesados.

La mejor manera de hacerlo, creo, sería usar argparse junto con cmd. En lugar de analizar sys.argv, se puede pasar el método parse_args a una lista de cadenas. Así que algo como la siguiente:

def do_addcd(self, line): 
    parser = argparse.ArgumentParser(prog='addcd') 
    parser.add_argument('--track', type=int) 
    parser.add_argument('--cdname') 

    args = parser.parse_args(line.split()) 
    newcd = CD(args.track, args.cdname) 

El problema de hacer algo como esto, como he encontrado a mí mismo tratando de hacer exactamente este tipo de cosas, es que parse_args tiende a salir todo el programa si se suministra con la cantidad incorrecta de argumentos, entre otros errores. El comportamiento deseado en este caso de uso sería simplemente salir de nuevo a su shell interactivo personalizado, pero no será fácil hacerlo sin una solución alternativa o una subclasificación de ArgumentParser y anulando parse_args.