Descarga typer - Descarga del código fuente typer

typer

Pitón

0.15.1

Descargar

Typer, crea excelentes CLI. Fácil de codificar. Basado en sugerencias de tipo Python.

Documentación : https://typer.tiangolo.com

Código fuente : https://github.com/fastapi/typer

Typer es una biblioteca para crear aplicaciones CLI que a los usuarios les encantará usar y a los desarrolladores les encantará crear . Basado en sugerencias de tipo Python.

También es una herramienta de línea de comandos para ejecutar scripts y convertirlos automáticamente en aplicaciones CLI.

Las características clave son:

Escritura intuitiva : excelente compatibilidad con el editor. Finalización por todas partes. Menos tiempo de depuración. Diseñado para ser fácil de usar y aprender. Menos tiempo leyendo documentos.
Fácil de usar : Es fácil de usar para los usuarios finales. Ayuda automática y finalización automática para todos los shells.
Breve : Minimiza la duplicación de código. Múltiples características de cada declaración de parámetro. Menos errores.
Comience de manera simple : el ejemplo más simple agrega solo 2 líneas de código a su aplicación: 1 importación, 1 llamada de función .
Crecer en grande : aumente en complejidad tanto como desee, cree árboles de comandos y grupos de subcomandos arbitrariamente complejos, con opciones y argumentos.
Ejecutar scripts : Typer incluye un comando/programa typer que puede usar para ejecutar scripts, convirtiéndolos automáticamente en CLI, incluso si no usan Typer internamente.

FastAPI de CLI

Typer es el hermano pequeño de FastAPI, es el FastAPI de las CLI.

Instalación

Cree y active un entorno virtual y luego instale Typer :

$ pip install typer
---> 100%
Successfully installed typer rich shellingham

Ejemplo

El mínimo absoluto

Crea un archivo main.py con:

 def main ( name : str ):
    print ( f"Hello { name } " )

Este script ni siquiera usa Typer internamente. Pero puedes usar el comando typer para ejecutarlo como una aplicación CLI.

ejecutarlo

Ejecute su aplicación con el comando typer :

 // Run your application
$ typer main.py run

// You get a nice error, you are missing NAME
Usage: typer [PATH_OR_MODULE] run [OPTIONS] NAME
Try 'typer [PATH_OR_MODULE] run --help' for help.
╭─ Error ───────────────────────────────────────────╮
│ Missing argument 'NAME'.                          │
╰───────────────────────────────────────────────────╯


// You get a --help for free
$ typer main.py run --help

Usage: typer [PATH_OR_MODULE] run [OPTIONS] NAME

Run the provided Typer app.

╭─ Arguments ───────────────────────────────────────╮
│ *    name      TEXT  [default: None] [required]   |
╰───────────────────────────────────────────────────╯
╭─ Options ─────────────────────────────────────────╮
│ --help          Show this message and exit.       │
╰───────────────────────────────────────────────────╯

// Now pass the NAME argument
$ typer main.py run Camila

Hello Camila

// It works! ?

Este es el caso de uso más simple, ni siquiera usa Typer internamente, pero ya puede ser bastante útil para scripts simples.

Nota : el autocompletado funciona cuando creas un paquete Python y lo ejecutas con --install-completion o cuando usas el comando typer .

Utilice Typer en su código

Ahora comencemos a usar Typer en tu propio código, actualiza main.py con:

 import typer


def main ( name : str ):
    print ( f"Hello { name } " )


if __name__ == "__main__" :
    typer . run ( main )

Ahora puedes ejecutarlo con Python directamente:

 // Run your application
$ python main.py

// You get a nice error, you are missing NAME
Usage: main.py [OPTIONS] NAME
Try 'main.py --help' for help.
╭─ Error ───────────────────────────────────────────╮
│ Missing argument 'NAME'.                          │
╰───────────────────────────────────────────────────╯


// You get a --help for free
$ python main.py --help

Usage: main.py [OPTIONS] NAME

╭─ Arguments ───────────────────────────────────────╮
│ *    name      TEXT  [default: None] [required]   |
╰───────────────────────────────────────────────────╯
╭─ Options ─────────────────────────────────────────╮
│ --help          Show this message and exit.       │
╰───────────────────────────────────────────────────╯

// Now pass the NAME argument
$ python main.py Camila

Hello Camila

// It works! ?

Nota : también puedes llamar a este mismo script con el comando typer , pero no es necesario.

Actualización de ejemplo

Este fue el ejemplo más simple posible.

Ahora veamos uno un poco más complejo.

Un ejemplo con dos subcomandos

Modifique el archivo main.py

Cree una aplicación typer.Typer() y cree dos subcomandos con sus parámetros.

 import typer

app = typer . Typer ()


@ app . command ()
def hello ( name : str ):
    print ( f"Hello { name } " )


@ app . command ()
def goodbye ( name : str , formal : bool = False ):
    if formal :
        print ( f"Goodbye Ms. { name } . Have a good day." )
    else :
        print ( f"Bye { name } !" )


if __name__ == "__main__" :
    app ()

Y eso será:

Cree explícitamente una aplicación typer.Typer .
- El typer.run anterior en realidad crea uno implícitamente para usted.
Agregue dos subcomandos con @app.command() .
Ejecute la propia app() , como si fuera una función (en lugar de typer.run ).

Ejecute el ejemplo actualizado

Consulta la nueva ayuda:

$ python main.py --help

 Usage: main.py [OPTIONS] COMMAND [ARGS]...

╭─ Options ─────────────────────────────────────────╮
│ --install-completion          Install completion  │
│                               for the current     │
│                               shell.              │
│ --show-completion             Show completion for │
│                               the current shell,  │
│                               to copy it or       │
│                               customize the       │
│                               installation.       │
│ --help                        Show this message   │
│                               and exit.           │
╰───────────────────────────────────────────────────╯
╭─ Commands ────────────────────────────────────────╮
│ goodbye                                           │
│ hello                                             │
╰───────────────────────────────────────────────────╯

// When you create a package you get  auto-completion  for free, installed with --install-completion

// You have 2 subcommands (the 2 functions): goodbye and hello

Ahora consulte la ayuda para el comando hello :

$ python main.py hello --help

 Usage: main.py hello [OPTIONS] NAME

╭─ Arguments ───────────────────────────────────────╮
│ *    name      TEXT  [default: None] [required]   │
╰───────────────────────────────────────────────────╯
╭─ Options ─────────────────────────────────────────╮
│ --help          Show this message and exit.       │
╰───────────────────────────────────────────────────╯

Y ahora revisa la ayuda para el comando goodbye :

$ python main.py goodbye --help

 Usage: main.py goodbye [OPTIONS] NAME

╭─ Arguments ───────────────────────────────────────╮
│ *    name      TEXT  [default: None] [required]   │
╰───────────────────────────────────────────────────╯
╭─ Options ─────────────────────────────────────────╮
│ --formal    --no-formal      [default: no-formal] │
│ --help                       Show this message    │
│                              and exit.            │
╰───────────────────────────────────────────────────╯

// Automatic --formal and --no-formal for the bool option ?

Ahora puedes probar la nueva aplicación de línea de comandos:

 // Use it with the hello command

$ python main.py hello Camila

Hello Camila

// And with the goodbye command

$ python main.py goodbye Camila

Bye Camila!

// And with --formal

$ python main.py goodbye --formal Camila

Goodbye Ms. Camila. Have a good day.

Resumen

En resumen, declara una vez los tipos de parámetros ( argumentos CLI y opciones CLI ) como parámetros de función.

Esto se hace con tipos estándar de Python modernos.

No es necesario aprender una nueva sintaxis, los métodos o clases de una biblioteca específica, etc.

Simplemente Python estándar.

Por ejemplo, para un int :

 total : int

o para una bandera bool :

 force : bool

Y de manera similar para archivos , rutas , enumeraciones (opciones), etc. Y existen herramientas para crear grupos de subcomandos , agregar metadatos, validación adicional, etc.

Obtiene : excelente soporte de editor, que incluye comprobaciones de finalización y escritura en todas partes.

Sus usuarios obtienen : --help automático, autocompletado en su terminal (Bash, Zsh, Fish, PowerShell) cuando instalan su paquete o cuando usan el comando typer .

Para obtener un ejemplo más completo que incluye más funciones, consulte el Tutorial - Guía del usuario.

Dependencias

Typer se encuentra sobre los hombros de un gigante. Su única dependencia interna requerida es Click.

Por defecto también viene con dependencias estándar adicionales:

rich : para mostrar automáticamente errores bien formateados.
shellingham : para detectar automáticamente el shell actual al finalizar la instalación.
- Con shellingham puedes usar --install-completion .
- Sin shellingham , debe pasar el nombre del shell para completar la instalación, por ejemplo, --install-completion bash .