Módulo Cmdparse en Python

La clase que proporciona un marco simple para escribir intérpretes de comandos orientados a líneas se llama clase cmd. Suelen ser útiles para herramientas administrativas, prototipos y arneses de prueba que luego se incluirán en una interfaz más sofisticada. La interfaz de línea de comandos se puede crear fácilmente con el módulo cmd.
Las interfaces gráficas de usuario se usan tanto en estos días que un intérprete de línea de comandos parece antiguo. La interfaz de línea de comandos puede tener varias ventajas: 
 

• La interfaz de línea de comandos es portátil y se puede ejecutar en cualquier lugar. 
   
• Los recursos de CPU y memoria son mucho más baratos que la interfaz GUI. 
   
• Es más fácil abrir el archivo con la línea de comandos que acceder a los controladores y buscar el menú. 
   
• Es mucho más rápido crear documentos orientados a texto. 
   

Clase de comando

El módulo define solo una clase: la clase Cmd. El intérprete de línea de comandos se crea subclasificando la clase cmd.Cmd. Una instancia de Cmd o una instancia de subclase se puede considerar como un marco de interpretación orientado a líneas. 
 

• Crear comando: la primera parte de una línea de texto ingresada en el indicador del intérprete es un comando. La string de caracteres más larga contenida en el miembro identchars es Comando. 
  Las letras no acentuadas, los dígitos y el símbolo de guión bajo son caracteres de identificación predeterminados. El final de la línea son los parámetros del comando. 
   
• Parámetro: el método do_xxx solo debe tomar un parámetro adicional y corresponde a la parte de la string ingresada por el usuario después del nombre del comando. 
   
• Errores: el intérprete utiliza el siguiente formato para señalar errores: 
   

*** : 

•  
• Valor devuelto: en el caso más común: los comandos no deberían devolver un valor. Cuando desea salir del ciclo del intérprete, cualquier comando que devuelva un valor verdadero detiene el intérprete es una excepción.
  Ejemplo: 
   

def add(self, d):
    k = d.split()
    if len(k)!= 2:
       print "*** invalid number of arguments"
       return
    try:
       k = [int(i) for i in k]
    except ValueError:
       print "*** arguments should be numbers"
       return
    print k[0]+k[1]

Módulo de análisis de cmd

El paquete cmdparser contiene dos módulos que son útiles para escribir analizadores de comandos de texto. 
Este módulo utiliza particularmente el módulo cmd de Python incorporado. El paquete consta de dos módulos:
 

• cmdparser.cmdparser 
   
• cmdparser.datetimeparse 
   

Instalación

Podemos instalar el paquete cmdparse desde PyPI. Por ejemplo 
 

pip install cmdparse

cmdparse

El módulo Cmd permite crear un árbol de análisis a partir de la especificación de comandos textuales como se muestra a continuación 
 

chips( spam | ham [eggs] | beans [eggs [...]] )

La string de comando particular se puede verificar usando estos árboles de análisis. Además, permite que se enumere la finalización válida de la string de comando parcial.
Ejemplo:
 

from cmdparser import cmdparser
 
parse_tree = cmdparser.parse_spec("abc (def|ghi) <jkl> [mno]")
 
# Returns None to indicate
# successful parse
parse_tree.check_match(("abc", "def", "anything"))
 
# Returns an appropriate
# parsing error message
parse_tree.check_match(("abc", "ghi", "anything", "pqr"))
 
# Returns the list ["def", "ghi"]
parse_tree.get_completions(("abc", ))

Producción:
 

Los tokens dinámicos se pueden configurar donde la lista de strings aceptadas puede cambiar con el tiempo, o donde se pueden aceptar strings arbitrarias o listas de strings mientras se trata de una string de token fija. Consulte las strings de documentación del módulo para conocer los detalles de las clases disponibles, pero como ejemplo:
 

from cmdparser import cmdparser
 
 
class fruitToken(cmdparser.Token):
     
    def get_values(self, context):
        # Static list here, but could
        # easily be dynamic
        return ["raspberry", "orange", "mango",
                "grapes", "apple", "banana"]
 
def my_ident_factory(token):
     
    if token == "number":
        return cmdparser.IntegerToken(token)
     
    elif token == "fruit":
        return fruitToken(token)
     
    return None
 
parse_tree = cmdparser.parse_tree("take <number> <fruit> bags",
                                  ident_factory = my_ident_factory)
 
# Returns None to indicate successful
# parse, and the "cmd_fields" dict will
# be initialised as:
# { "take": ["take"], "<number>": ["23"],
#   "<fruit>": ["apple"], "bags": ["bags"] }
cmd_fields = {}
 
parse_tree.check_match(("take", "23",
                        "apple", "bags"),
                       fields = cmd_fields)
 
# Returns an appropriate
# parsing error message
parse_tree.check_match(("take", "all",
                        "raspberry", "bags"))
 
# Returns the list ["raspberry",
# "orange", "mango", ..., "banana"]
parse_tree.get_completions(("take", "5"))

Producción:
 

Hay cuatro clases disponibles que son clases base adecuadas para tokens derivados del usuario: 
 

• Token: Cuando uno de los conjuntos de valor fijo es adecuado, esto es útil, donde la lista puede ser fija o dinámica. El método get_values() debe anularse para devolver una lista de tokens válidos como strings. 
   
• Anytoken: es similar a Token, pero se espera cualquier string. La validación se puede realizar a través del método de validación(), pero el método de validación() no permite completar con tabulación, ya que solo se llama una vez que se analiza todo el comando. También hay un método convert() en caso de que sea necesario 
   
• AnyTokenString: similar a AnyToken pero se consumen todos los elementos restantes en la línea de comando. 
   
• Subárbol: coincide con todo el subárbol de comandos y almacena el resultado contra el token especificado en el diccionario de campos. La string de especificación del comando debe pasarse al constructor, y las clases de tipos anularán el método convert() e interpretarán el comando de alguna manera (aunque esto es estrictamente opcional).
  Los decoradores están presentes para su uso con controladores de comandos derivados de cmd.Cmd, lo que permite que las strings de comandos se extraigan automáticamente del texto de ayuda de la string de documentación y permiten que se agreguen el análisis y la finalización de comandos a los métodos de manejo de comandos de la clase. 
  Se implementan varios métodos de la forma do_XXX() para implementar la clase cmd.Cmd.
   

from cmdparser import cmdparser
 
@cmdparser.CmdClassDecorator()
class CommandHandler(cmd.Cmd):
 
    @cmdparser.CmdMethodDecorator():
    def do_command(self, args, fields):
        """command ( add | delete ) <name>
 
        The example explains the use of
        command to demonstrate use of the cmd
        decorators.
        """
 
        # Method body - it will only be called
        # if a command parses successfully according
        # to the specification above.

datetimeparse

• El módulo Datetimeparse agrega tipos de token específicos para analizar especificaciones de fecha y hora legibles por humanos. Se especifican ambos tipos de fechas absolutas y relativas y esto se convierte a otras instancias según corresponda. 
  Algunos ejemplos son 
   

1:35 on friday last week
11 feb 2019

• Las clases actualmente definidas son: 
  • DateSubtree: incluye la fecha literal (2020-03-14), días de la semana relacionados con el día actual (sábado de la semana pasada), versión descriptiva (26 de junio de 2019), así como ayer, hoy y mañana junto con la fecha del calendario de análisis . El valor devuelto es una instancia de datetime.date. 
     
  • TimeSubtree: TimeSubtree analiza la hora del día en formato de 12 o 24 horas. El valor devuelto es el devuelto por time.localtime(). 
     
  • RelativeTimeSubtree: el valor devuelto es una instancia de cmdparser.DateDelta, que es una clase contenedora que contiene un datetime.timedelta. Analiza frases que indican una diferencia de tiempo con respecto al tiempo presente, como hace 3 días y 2 horas. 
     
  • DateTimeSubtree: la instancia datetime.datetime es el valor devuelto. DateTimeSubtree Analiza las especificaciones de una fecha y hora, aceptando una combinación de frases DateSubtree y TimeSubtree, o una frase RelativeTimeSubtree; en este último caso, la hora se toma en relación con la hora actual. 
     
  • CLassCalenderPeriodSubtree: analiza las especificaciones de los períodos del calendario en el pasado. El valor devuelto es una tupla de 2 de instancias de datetime.date que representa el rango de fechas especificado, donde la primera fecha es inclusiva y la segunda exclusiva.