Pipenv: gestor de entornos virtuales de Python

Si queremos tener un gestor que nos unifique y gestione tanto Virtualenv como Pip podemos utilizar Pipenv. Pipenv funciona en Windows, Linux y Mac; y en todos los sistemas operativos funciona exactamente igual (cambiando la ruta donde se guardan las cosas). La mayor cualidad de Pipenv es que crea (y gestiona) entornos virtuales exclusivos en una carpeta separada del proyecto y nos facilita los ficheros de requisitos.

Antes de empezar con Pipenv, recomiendo encarecidamente tener unas nociones básicas sobre «entornos virtuales de Python» sobre todo los exclusivos por proyecto. Para ello puedes echar un ojo al artículo que hemos creado sobre Entornos virtuales de Python: común y Anaconda (aunque se puede leer por separado perfectamente, este artículo está diseñado como continuación de este otro).

Nota sobre Pipenv y Anaconda: No recomiendo utilizar Pipenv con Anaconda, ya que Anaconda hace más o menos lo mismo que “Pipenv” salvo por alguna excepción (se puede usar Pipenv con Anaconda, pero es tener un “gestor de entornos virtuales” dentro de un “gestor de entornos virtuales” cada uno gestionando entornos virtuales por su lado y a su modo). Recomiendo Pipenv si se trabaja sobre “Python común”. Pipenv se instala con PIP en la carpeta “Lib” del “Python global” (sino tienes instalado Virtualenv lo instalará automáticamente como dependencia pues lo necesita). Cuando lo instalemos Pipenv tendremos unas cuantas variables de entorno de Python en el sistema operativo (que podremos usar en la consola) que enumero para tenerlas claras: python, pip, virtualenv, pipenv. Usaremos la nueva “pipenv” para gestionar los entornos virtuales (así que nos olvidamos de utilizar “virtualenv” y sus comandos; aunque pipenv utiliza comandos semejantes). Pipenv creará los entornos virtuales (usa por debajo Virtualenv) en una carpeta que gestiona llamada “virtualenvs” y si le pasamos paquetes en la creación podremos instalarlos (usa por debajo PIP).

Pipenv creará un entorno virtual por proyecto en la carpeta “virtualenvs” que llamará con el mismo nombre que el proyecto seguido de un identificador. Y dentro del proyecto creará un fichero de requisitos llamado “Pipfile” (y “Pipfile.lock”; ambos los veremos más adelante) que nos servirá para recrear el entorno virtual (con la misma versión de Python y mismos paquetes con las mismas versiones) en otro lado u otra máquina diferente (sin tener que copiar la carpeta entera del entorno virtual, que no es una buena práctica).

Instalar Pipenv

“Pipenv” se instala con el comando (no viene incorporado):

pip install pipenv

Usar Pipenv

Desde la consola del sistema entra dentro de un proyecto que tengas o crea uno nuevo como se sugiere en el siguiente cuadro.

mkdir mi_proyecto

cd mi_proyecto

Crear un entorno virtual

Crear un entorno virtual exclusivo para un proyecto (ir a la carpeta principal del proyecto y ejecutar) con:

pipenv install

En Linux/Mac verás algo así:

En Windows funciona exactamente igual:

Cuando se cree el entorno virtual, automáticamente se nombrará con el nombre de la carpeta raíz seguido de un identificador y se guardará en (en la imagen he marcado con un recuadro dorado la ruta donde se te habrá creado el entorno virtual):

• En Linux/Mac: /home/<USUARIO>/.local/share/virtualenvs/
• En Windows: C:\Users\<USUARIO>\.virtualenvs\

pipenv --venv

Esto liberará nuestro proyecto de código y de ficheros que no se deben compartir/distribuir; en su lugar creará dos ficheros con los “requisitos del entorno virtual exclusivo” dentro de nuestro proyecto que sí se deben compartir/distribuir: “Pipfile.lock” y “Pipfile”.

Estos dos ficheros “Pipfile.lock” y “Pipfile” son los requisitos de nuestro proyecto con la configuración del entorno virtual exclusivo; que los creó Pipenv al crear el entorno virtual, en un futuro los completará cuando instalemos dependencias (añadirá un par de líneas con las información del paquete que instalemos, como su nombre y la versión), los podremos modificar para cambiar la configuración a mano (como cambiar la versión de Python), y en última instancia podremos regenerar desde ellos el entorno virtual (tanto si algo falla del entorno virtual para poder recrearlo, así como para copiar/mover nuestro proyecto a otra máquina para crear el entorno virtual con exactamente la configuración necesaria para que nuestro proyecto funcione). Aunque explicaré estos dos ficheros con detalle más adelante, para que se vea como guarda los paquetes que deseemos instalar, sugiero que los abras y les eches un vistazo rápido.

Activar un entorno virtual

Para activar el entorno virtual (estando en la misma raíz del proyecto a donde creamos el entorno virtual; es decir, en la misma ruta donde están los dos ficheros de requisitos “Pipfile.lock” y “Pipfile”):

pipenv shell

Para mi caso al activar el entorno virtual me aparecerá delante de la ruta “(mi_proyecto)” para indicar que se ha activado correctamente (si te fijas, Pipenv ha llamado automáticamente al “activate” de Virtualenv; es decir, lo mismo que hicimos antes, pero gestionado con Pipenv):

Instalar dependencias (paquetes) en un entorno virtual

Para instalar paquetes de Python desde el repositorio de PIP (https://pypi.org/; en el siguiente ejemplo instalaré el paquete sorted-in-disk, instala el que quieras para probar, parecido a como hice en el artículo Entornos virtuales de Python: común y Anaconda):

pip install sorted-in-disk

Nota para agilizar la instalación de un entorno virtual con uno o varios paquetes: La ventaja de utilizar el comando de la instalación del entorno virtual es que se puede aprovechar a instalar algún paquete con PIP a la que creamos el entorno virtual (este comando crea el entorno virtual sino existe y luego los paquetes desde el repositorio de PIP):

pipenv install <PAQUETE1> <PAQUETE2> <PAQUETEN>

Para mi ejemplo los paquetes se instalarán dentro de la carpeta “lib” que está dentro del entorno virtual exclusivo de mi proyecto:

• Linux/Mac: /home/<USUARIO>/.local/share/virtualenvs/mi_proyecto-OFFUWq_4/lib/python3.8/
• Windows: c:\users\<USUARIO>\.virtualenvs\mi_proyecto-jr0nmums\lib\site-packages\

Par ver todos los paquetes (con sus dependencias) instaladas por PIP los podemos listar con:

pip list --local

O también con:

pipenv graph

En la siguiente imagen muestro un ejemplo de ambos:

Aquí como podremos utilizar Python aislado en este entorno virtual:

python

Y probar a escribir código para ver que funciona, probar los paquetes instalados, escribir ficheros y ejecutarlos, etc. Vamos lo normal en Python 😉

En la siguiente imagen pruebo el mismo código Python que usé en el artículo Entornos virtuales de Python: común y Anaconda bajo este entorno virtual gestionado por Pipenv:

Desactivara un entorno virtual

Y para desactivar el entorno virtual simplemente escribimos:

exit

Nota sobre el comando “deactivate”: a fecha de creación de este artículo el comando “deactivate” no funcionaba correctamente, desactivando parcialmente el entorno virtual (parece que desactiva la parte de Virtualenv, pero no la gestionada por Pipenv; así que para que se entere Pipenv usa mejor “exit” y que sea quien gestione la desactivación del entorno virtual).

Eliminar un entorno virtual

Para eliminar el entorno virtual (solo elimina la carpeta con el entorno virtual en la carpeta “virtualenvs”; no elimina los ficheros de requerimientos “Pipfile.lock” y “Pipfile”):

pipenv --rm

Nota sobre los ficheros “Pipfile.lock” y “Pipfile”: quedan sin eliminar para futuras reinstalaciones y porque es parte de la información del proyecto. Si quieres eliminarlos puedes hacerlo a mano con:

rm Pipfile Pipfile.lock

Ficheros de requisitos “Pipfile.lock” y “Pipfile”

Los ficheros “Pipfile.lock” y “Pipfile” son los ficheros de requisitos donde se guarda la configuración completa del entorno virtual de Python (Virtualenv) gestionado por Pipenv.

Estos serán muy útiles si en un futuro copiamos/distribuimos la carpeta de nuestro proyecto que contenga estos dos ficheros a cualquier otra máquina (otro ordenador u otro servidor), y si volvemos ejecutamos el comando en esa otra máquina:

pipenv install

Se regenerará el entorno virtual de Python exclusivo para este proyecto con dichos requisitos (con los paquetes instalados, con la versión de Python necesaria, etc.) y para esa otra máquina (si la máquina tiene alguna peculiaridad, se usará el Python global previamente configurado y funcionando en esa máquina, por lo que nos aseguramos de que funcionará); de este modo, nuestro proyecto funcionará perfectamente en esa otra máquina.

“Pipfile” contiene información general (explico los que vienen por defecto):

• [source]: desde donde se conecta PIP para descargar los paquetes (se podría configurar para que descargue los paquetes de un repositorio privado de una empresa, por ejemplo).
• [dev-packages]: los paquetes que sean exclusivos para el desarrollo (como los paquetes para realizar test, para comprobar rendimiento, de recogida de logs, etc.). Estos paquetes se pueden excluir para cuando tengamos una versión de nuestro proyecto para ser lanzada (release).
• [packages]: los paquetes que queremos utilizar en nuestro proyecto y que serán incluidos en la versión lanzada (release).
• [requires]: nos permitirá cambiar la versión de Python si lo deseamos cambiando el número de versión en “python_version” (siempre y cuando tengamos el Python global con la versión deseada; es decir, por defecto toma la última versión instalada que en mi caso es Python 3.8, si queremos que nos funcione con Python 2 pues debemos tener instalado como global Python 2).

[[source]]
name = "pypi"
url = "https://pypi.org/simple"
verify_ssl = true

[dev-packages]

[packages]
sorted-in-disk = "*"

[requires]
python_version = "3.8"

Podemos modificar a mano cualquier cosa, por ejemplo, la versión de Python, guardaríamos el fichero y es importante eliminar el entorno virtual (sino lo hacemos nos mostrará un mensaje de advertencia) con:

pipenv --rm

Y lo volvemos a crear con:

pipenv install

El fichero de requisitos más importante es “Pipfile”, con este fichero Pipenv generará el entorno virtual (al ejecutar “pipenv install” sino existe uno previo generará un fichero “Pipfile” por defecto; si existe, lo leerá y aplicará dicha configuración) y creará el fichero “Pipfile.lock” (lo mismo, sino existe se creará y si existe se leerá). El fichero “Pipfile.lock” es también importante para nuestro proyecto ya que definirá las versiones concretas con las que funcionará nuestro proyecto; es decir, nos asegurará una configuración en concreto (“bloqueará una configuración”, por eso lo de “lock”), para que no se cambien las versiones (principalmente para que no se actualicen las versiones de paquetes o Python) si copiamos/distribuimos nuestro proyecto y por ello nos aseguramos que funcione correctamente en cualquier máquina.

“Pipfile.lock” no debería ser modificado a mano, mejor regenerarlo desde “Pipfile”, contiene información parecida a la siguiente en formato JSON:

{
    "_meta": {
        "hash": {
            "sha256": " 0123456789abcdf0123456789abcdf0123456789abcdf0123456789abcdf0123"
        },
        "pipfile-spec": 6,
        "requires": {
            "python_version": "3.8"
        },
        "sources": [
            {
                "name": "pypi",
                "url": "https://pypi.org/simple",
                "verify_ssl": true
            }
        ]
    },
    "default": {
        "easy-binary-file": {
            "hashes": [
                "sha256: 0123456789abcdf0123456789abcdf0123456789abcdf0123456789abcdf0123",
                "sha256: 0123456789abcdf0123456789abcdf0123456789abcdf0123456789abcdf0123"
            ],
            "markers": "python_version >= '3.0'",
            "version": "==1.0.4"
        },
        "quick-queue": {
            "hashes": [
                "sha256: 0123456789abcdf0123456789abcdf0123456789abcdf0123456789abcdf0123",
                "sha256: 0123456789abcdf0123456789abcdf0123456789abcdf0123456789abcdf0123"
            ],
            "markers": "python_version >= '3.0'",
            "version": "==1.0.5"
        },
        "sorted-in-disk": {
            "hashes": [
                "sha256: 0123456789abcdf0123456789abcdf0123456789abcdf0123456789abcdf0123",
                "sha256: 0123456789abcdf0123456789abcdf0123456789abcdf0123456789abcdf0123"
            ],
            "index": "pypi",
            "version": "==1.0.3"
        }
    },
    "develop": {}
}

Si echas un vistazo rápido a este fichero verás el paquete que he instalado (en este caso encontrarás “sorted-in-disk”), sus dependencias (si las tiene) y lo más importante, la versión concreta (para “sorted-in-disk” se lee “version”: “==1.0.3”), entre otra información como hashes, etc. Como indiqué antes y aunque tiente cambiar aquí las versiones, todo este JSON creado por “Pipfile.lock” no deberíamos tocarlo (pero sí guardarlo); si quieres modificar algo mejor tocar “Pipfile” y recrear este fichero “Pipfile.lock” con el comando “pipenv install”.

Tanto “Pipfile.lock” como “Pipfile” son parte imprescindible del proyecto por lo que deberían ser incluidos en un control de versiones (un repositorio como Git).

Bibliografía

• https://pypi.org/project/pipenv/
• https://github.com/pypa/pipenv
• https://docs.pipenv.org/
• https://stackoverflow.com/questions/41573587/what-is-the-difference-between-venv-pyvenv-pyenv-virtualenv-virtualenvwrappe?rq=1