LOG
Voy a comenzar las utilidades icerv, que son las excusa para documentar, aprender y afianzar conocimientos diversos. Voy a intentar hacer todo desde el vscode, definiendo las tareas necesarias. Quiero evitar, en la medida de lo posible, utilizar la línea de comandos. Creo que esto es la clave para enseñar a las personas recién llegadas a la tecnología
Empiezo creando el repo desde cero, y creando el fichero get-rars.py:
print("Hola...")
print("Vaamos!")Este es el estado en el vs-code (1.90.2)
Estas son las extensiones que tengo instaladas para trabajar con python: Python, Python Debugger, Python Environment Manager, Pylance, isort
Pinchando en el icono de python de la izquierda se pueden ver los diferentes entornos y versiones de python que están instaladas
Con estas extensiones instaladas, y sin hacer nada adicional se puede ejecutar el programa get-rars.py. Nos vamos a la parte de depuración y pinchamos en Run and Debug
Pinchamos ahora en la opción Python File
Se abre un terminal en la parte de la izquierda y se ejecuta el archivo de python llamando al intérprete de python que teníamos seleccionados (python 3.10 en este caso)
Si queremos simplemente ejecutar el archivo python rápidamente, siempre podemos pinchar en el botón de play que hay en la parte superior derecha de la ventana de edición
Al pinchar, se abre el terminal y se ejecuta el archivo con el python actual:
También podemos depurar de una manera rápida. Primero ponemos un breakpoint (1), luego pinchamos en la flecha situada a la derecha del botón de play anterior (2) y seleccionamos la opción Debug python file:
Al hacerlo se abre el terminal y se ejecuta el programa de python en modo depuración. Vemos cómo se pasa automáticamente al modo depuración. Nos aparecen los controles de depuración en la parte superior y el programa se para en el primer breakpoint
Ahora apretamos en la opción de step over (Tecla F10) para ejecutar la instrucción actual. En el terminal vemos que aparece el mensaje "Hola". También vemos cómo ahora se para en la siguiente instrucción, que queda a la espera para ejecutarse
Si ahora volvemos a apretar F10, se ejecuta la siguiente instrucción (que es la última). Aparece el siguiente mensaje: "vaamos!" y, como es la última instrucción, se sale del modo depuración
Nos fijamos que ahora el símbolo del play ha cambiado: tiene el icono de play y un bicho (bug). Esto nos permite volver a depurar simplemente con pincharlo de nuevo. La última operación seleccionada es la que queda visible
Los ejemplos anteriores se han ejecutado con el entorno de python 3.10.2, que es el que estaba por defecto. Pero esto lo podemos cambiar. Podemos seleccionar cualquier de los que tengamos instalados en el sistema. Pinchamos en el icono de python de la parte izquierda, y nos aparecerá en el lateral izquierdo todos los entornos python disponibles
En la parte superior aparece el entorno actual (y también lo vemos en la esquina inferior derecha). Vamos a Ejecutar el script de pruebas pero usando python 3.8, por ejemplo. Para ello seleccionamos python 3.8.18 y pinchamos en el icono de la estrella
Al hacerlo nos cambia el entorno por defecto, y lo vemos reflejado en el laterior izquierdo (parte superior) y también en la esquina inferior derecha
Si ahora ejecutamos el script como ya sabemos hacer, el entorno que se usa es 3.8.18 y NO el anterior 3.10.2
Lo interesante de todo esto es que podemos crear los entornos virtuales fácilmente, sin usar la línea de comandos. Para ello pinchamos en el icono de python (como antes), y le damos al icono '+' que está en la izquierda de Venv
Se nos abre un desplegable en el que está señalado el entorno de python actual. Seleccionamos la versión de python que queremos incluir en nuestro entorno virtual. Por ejemplo la última: python 3.10.12
Nos aparece una notificación en la parte interior indicando que se está creando el entorno virtual de python. Nos aparecerá otra en paralelo que nos dice si queremos seleccionar este entorno para trabjar con él
De momento pinchamos en NO, para hacerlo manualmente
Vemos que nos aparece ahora el nuevo entorno virtual dentro de la carpeta Venv:
Y se comporta como otro entorno más. Así que lo podemos seleccionar pinchando en la estrella
Ese entorno virtual es nuestro python por defecto! Si miramos los archivos vemos que se ha creado la carpeta .venv, que es la que contiene nuestro entorno virtual
Ahora ejecutammos el script get-rars.py:
Vemos que en el terminal efectivamente estamos dentro del entorno virtual .venv
Lo interesante es que podemos ver qué paquetes hay instalados en el entorno virtual. Por defecto no hay ninguno, salvo pip y setuptools
La instalación de paquetes es muy fácil!!! Seleccionamos el entorno donde queremos instalar los paquetes y pinchamos en la lupa:
Escribirmos el nombre del paquete a instalar, o bien cualquier otro nombre para hacer una búsqueda. Vamos a probar a instalar el paquete colorama
Pinchamos en colorama y se nos instala automáticamente. Ahora lo podemos ver dentro del entorno:
Vamos a comprobar que funciona. Modificamos el código para imprimir mensajes en color, siguiendo la API de colorama:
from colorama import Fore, Style
print("Hola...")
print("Vaamos!")
print(Fore.RED + "Texto en Rojo!!")
print(Fore.GREEN + "Texto en verde")
print(Style.RESET_ALL)
print("Normal")
Note
Podría ocurrir que no detecte el módulo colorama y que el editor lo muestre subrayado con error. En ese caso cerrar el proyecto y volver a abrirlo para que se refresque todo
Ahora ya lo podemos ejecutar con normalidad, y veremos los textos en color:
Los paquetes se desinstalan muy fácilmente. Sólo hay que seleccionar el paquete en cuestión y pinchar en el icono de la basura
Al seleccionar un paquete tenemos la opción de volcar a un fichero todas las dependencias:
Se nos crea el fichero requirements.txt con TODAS las dependencias. Aunque en este ejemplo sólo hay una única dependencia (colorama)
Para el analisis de los programas en python hay dos utilidades muy extendidas: flake8 y pylint. Vamos a configurar primero pylint. Lo instalamos como ya sabemos. Nos aparecerá como dependencia del paquete, aunque también aparecerán todos el resto de paquetes de los que depende pylint
Primero vamos a utilizar pylint desde el terminal. Abrimos el terminal (o usamos el que ya había abierto de la ejecución) y ejecutamos el comando: pylint get-rars.py
Vemos cómo nos aparecen varios errores. Y delante del comando ejecutado aparece una cruz roja indicando que se ha ejecutado con errores. Esto es lo bueno del lint. Aunque es un programa extremadamente sencillo, hay cosas que se pueden mejorar
Antes de arreglar el código vamos a automatizar esta tarea de Lint. No queremos escribirla en el terminal (aunque por supuesto podríamos hacerlo)
Vamos a configurar una tarea para que se ejecute el comando pylint get-rars.py. Pinchamos en Terminar/Run Task. Se nos abre un desplegable. Seleccionamos la opción Configure a task
En el siguiente desplegable seleccionamos Create tasks.json from template
Y luego Others
Se nos crea el fichero tasks.json, dentro de la carpeta .vscode, con una tarea "hola mundo". Esta tarea se llama echo y simplemente ejecuta el comando echo Hello en un terminal.
Este es el fichero:
{
"version": "2.0.0",
"tasks": [
{
"label": "echo",
"type": "shell",
"command": "echo Hello"
}
]
}Para comprobar su funcionamiento lo vamos a ejecutar. Pinchamos en Terminal/Run task, y en el desplegable que aparece veremos la nueva tarea creada: echo
La ejecutamos. En el nuevo desplegable pinchamos en la primera opción: continue without scanning the task output
Se nos abre el terminal y se ejecuta el comando. Ahí podemos ver el mensaje Hello
Editamos el fichero task.json para modifar la tarea echo por Lint, y que se ejecute el comando pylint get-rars.py (o también el comando equivalente python -m pylint get-rars.py
Esta es el nuevo tasks.json:
{
"version": "2.0.0",
"tasks": [
{
"label": "Lint",
"detail": "pylint",
"type": "shell",
"command": "${command:python.interpreterPath}",
"args": ["-m", "pylint", "get-rars.py"],
}
]
}El comando que se ejecuta se le pasa a través de una variable del sistema de vscode: ${command:python.interpreterPath} que tiene el path del intérprete de python que tenemos seleccionado. Los argumentos se pasan como un array de cadenas. Cada elemento es uno de los parámetros que pasamos, que en la linea de comandos van separados por espacios. En este caso estamos ejecutando python -m pylint get-rars.py
Para ejecutarlo lo hacemos igual que con la tarea echo. Pinchamos en Terminar/Run Task. Ahí nos aparece la nueva tarea: Lint
Al pinchar nos vuelve a aparecer un desplegable, donde indicamos la opción continue without scanning the task output. Pinchamos en ella...y se nos ejecuta el lint
Ya tenemos el comando pylint get-rars.py automatizado, pero ahora vamos a integrarlo mejor con el vscode. Configuramos la tarea de lint para que se parsee el mensaje de salida y obtener la línea donde se produce el error, para que se nos indique directamente en el código. Este es el nuevo tasks.json:
{
"version": "2.0.0",
"tasks": [
{
"label": "Lint",
"detail": "pylint",
"type": "shell",
"command": "${command:python.interpreterPath}",
"args": ["-m", "pylint", "get-rars.py"],
"problemMatcher": {
"owner": "python",
"fileLocation": [
"relative",
"${workspaceFolder}"
],
"pattern": {
"regexp": "^(.*):(\\d+):(\\d+):\\s+(W|E|C).+:\\s+(.*)$",
"file": 1,
"line": 2,
"column": 3,
"severity": 4,
"message": 5
}
}
}
]
}Se ha añadido la propiedad problemMatcher que es la que parsea y extrae la información para que el vscode muestre la línea del error, así como el propio error
Ahora, además, como hemos configurado esa propiedad, al ejecutar la tarea Lint ya no nos preguntará nada más... directamente la ejecutará, parseará el resultado y nos lo mostrará gráficamente
Por último cambiamos la presentación. Queremos que se limpie el terminal antes de ejecutar el comando, y que NO salga el mensaje final. Todo esto lo configuramos en la propiedad presentation
{
"version": "2.0.0",
"tasks": [
{
"label": "Lint",
"detail": "pylint",
"type": "shell",
"command": "${command:python.interpreterPath}",
"args": ["-m", "pylint", "get-rars.py"],
"presentation": {
"echo": true,
"reveal": "always",
"focus": false,
"panel": "shared",
"showReuseMessage": false,
"clear": true,
},
"problemMatcher": {
"owner": "python",
"fileLocation": [
"relative",
"${workspaceFolder}"
],
"pattern": {
"regexp": "^(.*):(\\d+):(\\d+):\\s+(W|E|C).+:\\s+(.*)$",
"file": 1,
"line": 2,
"column": 3,
"severity": 4,
"message": 5
}
}
}
]
}Con esto ¡ya lo tenemos listo!
Ahora que ya lo tenemos integrado, vamos a solucionar los problemas del lint. El Lint nos dice que hay que añadir documentación al inicio, así como modificar el nombre del fichero. Lo solucionamos y volvemos a lanzar el lint:
Ahora ya no aparece ningún error!!
La tarea de lint que tenemos hasta ahora sólo actúa en el fichero get_rars.py. Para que actúe en el fichero que tenemos abierto en el editor modificamos el fichero task.json para utilizar la variable del sistema ${file}. Así es como queda el task.json definitivo:
{
"version": "2.0.0",
"tasks": [
{
"label": "Lint",
"detail": "pylint",
"type": "shell",
"command": "${command:python.interpreterPath}",
"args": ["-m", "pylint", "${file}"],
"presentation": {
"echo": true,
"reveal": "always",
"focus": false,
"panel": "shared",
"showReuseMessage": false,
"clear": true,
},
"problemMatcher": {
"owner": "python",
"fileLocation": [
"relative",
"${workspaceFolder}"
],
"pattern": {
"regexp": "^(.*):(\\d+):(\\d+):\\s+(W|E|C).+:\\s+(.*)$",
"file": 1,
"line": 2,
"column": 3,
"severity": 4,
"message": 5
}
}
}
]
}Una utilidad muy interesante en python es el paquete black, que formatea automáticamente el código para cumplir con los códigos de estilo. Para utilizarlo instalamos el paquete black como ya sabemos, y ejecutamos en la consola python -m black get_rars.py
En el archivo task.json añadimos una nueva configuración:
{
"label": "Format",
"detail": "black",
"type": "shell",
"command": "${command:python.interpreterPath}",
"args": ["-m", "black", "${file}"],
"presentation": {
"echo": true,
"reveal": "always",
"focus": false,
"panel": "shared",
"showReuseMessage": false,
"clear": true,
},
"problemMatcher": []
}Ahora al ejecutar la opción Terminal/Run Tasks nos aparecen las dos tareas configuradas
Ejecutamos el formateador:
Nos indica que no se ha modificado nada porque el código ya está bien formateado
Ya sabemos depurar los programas, de manera fácil. Pero vamos a configurarlo manualmente porque tenemos más opciones para, y también porque nos servirá para depurar otros programas que no están en python
Pinchamos en la parte de depuración y luego en create a launch.json file
En el desplegable que aparece pinchamos en Python Debugger
Y ahora en Python File
Se nos crea el fichero .vscode/launch.json:
{
"version": "0.2.0",
"configurations": [
{
"name": "Python Debugger: Current File",
"type": "debugpy",
"request": "launch",
"program": "${file}",
"console": "integratedTerminal"
}
]
}Ahora ya podemos depurar. Ponemos un Breakpoint y ejecutamos la tarea: "Python Debugger: Current File"
Y la depuración comienza!!!
(TODO)
https://docs.python.org/3/library/unittest.html
Hay dos frameworks: unittest y pytest. El primero está integrado en el estándar de python. El segundo es el que se usa en apio/icm