Inicio>Relacionado con la programación>Pitón
Descargar

Pipenv: flujo de trabajo de desarrollo de Python para humanos

Pipenv es una herramienta de administración de virtualenv de Python que admite una multitud de sistemas y cierra las brechas entre pip, python (usando el sistema python, pyenv o asdf) y virtualenv. Linux, macOS y Windows son ciudadanos de primera clase en pipenv.

Pipenv crea y administra automáticamente un virtualenv para sus proyectos, además de agregar/eliminar paquetes de su Pipfile a medida que instala/desinstala paquetes. También genera un proyecto Pipfile.lock , que se utiliza para producir compilaciones deterministas.

Pipenv está destinado principalmente a proporcionar a los usuarios y desarrolladores de aplicaciones un método sencillo para llegar a un entorno de proyecto de trabajo consistente.

Los problemas que Pipenv busca resolver son multifacéticos:

  • Ya no necesitas usar pip y virtualenv por separado: funcionan juntos.
  • Administrar un archivo de requirements.txt con hash de paquete puede resultar problemático. Pipenv usa Pipfile y Pipfile.lock para separar las declaraciones de dependencia abstractas de la última combinación probada.
  • Los hashes están documentados en el archivo de bloqueo y se verifican durante la instalación. Las consideraciones de seguridad se anteponen.
  • Fomente firmemente el uso de las últimas versiones de dependencias para minimizar los riesgos de seguridad que surgen de componentes obsoletos.
  • Le brinda información sobre su gráfico de dependencia (por ejemplo, $ pipenv graph ).
  • Optimice el flujo de trabajo de desarrollo admitiendo personalizaciones locales con archivos .env .

Tabla de contenido

  • pipenv

  • Instalación

  • Características

  • Conceptos básicos

  • Otros comandos

  • Finalización del caparazón

  • Uso

    • Ejemplos de uso

    • Comandos

    • Localizar el proyecto

    • Localice el entorno virtual

    • Localice el intérprete de Python

    • Instalar paquetes

    • Instalando desde git

    • Instalar una dependencia de desarrollo

    • Mostrar un gráfico de dependencia

    • Generar un archivo de bloqueo

    • Instalar todas las dependencias de desarrollo

    • Desinstalar todo

    • Usa el caparazón

  • Documentación

Instalación

Pipenv se puede instalar con Python 3.7 y superior.

Para la mayoría de los usuarios, recomendamos instalar Pipenv usando pip : 

 pip install --user pipenv

O, si estás usando FreeBSD: 

 pkg install py39-pipenv

O, si estás usando Gentoo: 

 sudo emerge pipenv

O, si estás usando Void Linux: 

 sudo xbps-install -S python3-pipenv

Alternativamente, algunos usuarios prefieren usar Pipx: 

 pipx install pipenv

O algunos usuarios prefieren usar el módulo pip de Python 

 python -m pip install pipenv

Consulte la documentación para obtener las instrucciones más recientes.

?

Características

  • Permite compilaciones verdaderamente deterministas y, al mismo tiempo, especifica fácilmente sólo lo que desea .
  • Genera y verifica hashes de archivos para detectar dependencias bloqueadas.
  • Instale automáticamente los Python necesarios, si pyenv o asdf están disponibles.
  • Encuentra automáticamente el inicio de su proyecto, de forma recursiva, buscando un Pipfile .
  • Genera automáticamente un Pipfile , si no existe ninguno.
  • Crea automáticamente un entorno virtual en una ubicación estándar.
  • Agrega/elimina automáticamente paquetes a un Pipfile cuando se instalan/desinstalan.
  • Carga automáticamente archivos .env , si existen.

Para obtener referencia de comandos, consulte Comandos.

Conceptos básicos

  • Se creará automáticamente un virtualenv cuando no exista ninguno.
  • Cuando no se pasan parámetros a install , se instalarán todos los paquetes [packages] especificados.
  • De lo contrario, cualquier valor predeterminado de virtualenv será el predeterminado.

Finalización del caparazón

Para habilitar la finalización en fish, agregue esto a su configuración ~/.config/fish/completions/pipenv.fish : 

 eval (env _PIPENV_COMPLETE=fish_source pipenv)

¡También hay un complemento para peces, que activará automáticamente tus subcapas por ti!

Alternativamente, con zsh, agregue esto a su configuración ~/.zshrc : 

 eval "$(_PIPENV_COMPLETE=zsh_source pipenv)"

Alternativamente, con bash, agregue esto a su configuración ~/.bashrc o ~/.bash_profile : 

 eval "$(_PIPENV_COMPLETE=bash_source pipenv)"

¡Las completaciones de caparazones mágicos ahora están habilitadas!

Uso 

 $ pipenv --help
Usage: pipenv [OPTIONS] COMMAND [ARGS]...

Options:
  --where                         Output project home information.
  --venv                          Output virtualenv information.
  --py                            Output Python interpreter information.
  --envs                          Output Environment Variable options.
  --rm                            Remove the virtualenv.
  --bare                          Minimal output.
  --man                           Display manpage.
  --support                       Output diagnostic information for use in
                                  GitHub issues.
  --site-packages / --no-site-packages
                                  Enable site-packages for the virtualenv.
                                  [env var: PIPENV_SITE_PACKAGES]
  --python TEXT                   Specify which version of Python virtualenv
                                  should use.
  --clear                         Clears caches (pipenv, pip).  [env var:
                                  PIPENV_CLEAR]
  -q, --quiet                     Quiet mode.
  -v, --verbose                   Verbose mode.
  --pypi-mirror TEXT              Specify a PyPI mirror.
  --version                       Show the version and exit.
  -h, --help                      Show this message and exit.

Ejemplos de uso: 

  Create a new project using Python 3.7, specifically:
  $ pipenv --python 3.7

  Remove project virtualenv (inferred from current directory):
  $ pipenv --rm

  Install all dependencies for a project (including dev):
  $ pipenv install --dev

  Create a lockfile containing pre-releases:
  $ pipenv lock --pre

  Show a graph of your installed dependencies:
  $ pipenv graph

  Check your installed dependencies for security vulnerabilities:
  $ pipenv check

  Install a local setup.py into your virtual environment/Pipfile:
  $ pipenv install -e .

  Use a lower-level pip command:
  $ pipenv run pip freeze

Comandos: 

  check         Checks for PyUp Safety security vulnerabilities and against
                PEP 508 markers provided in Pipfile.
  clean         Uninstalls all packages not specified in Pipfile.lock.
  graph         Displays currently-installed dependency graph information.
  install       Installs provided packages and adds them to Pipfile, or (if no
                packages are given), installs all packages from Pipfile.
  lock          Generates Pipfile.lock.
  open          View a given module in your editor.
  requirements  Generate a requirements.txt from Pipfile.lock.
  run           Spawns a command installed into the virtualenv.
  scripts       Lists scripts in current environment config.
  shell         Spawns a shell within the virtualenv.
  sync          Installs all packages specified in Pipfile.lock.
  uninstall     Uninstalls a provided package and removes it from Pipfile.
  update        Runs lock, then sync.
  upgrade       Update the lock of the specified dependency / sub-dependency,
                but does not actually install the packages.
  verify        Verify the hash in Pipfile.lock is up-to-date.

Localice el proyecto: 

 $ pipenv --where
/Users/kennethreitz/Library/Mobile Documents/com~apple~CloudDocs/repos/kr/pipenv/test

Localice el entorno virtual: 

 $ pipenv --venv
/Users/kennethreitz/.local/share/virtualenvs/test-Skyy4vre

Localice el intérprete de Python: 

 $ pipenv --py
/Users/kennethreitz/.local/share/virtualenvs/test-Skyy4vre/bin/python

Instalar paquetes: 

 $ pipenv install
Creating a virtualenv for this project...
...
No package provided, installing all dependencies.
Virtualenv location: /Users/kennethreitz/.local/share/virtualenvs/test-EJkjoYts
Installing dependencies from Pipfile.lock...
...

To activate this project's virtualenv, run the following:
$ pipenv shell

Instalando desde git:

Puedes instalar paquetes con pipenv desde git y otros sistemas de control de versiones usando URL formateadas de acuerdo con la siguiente regla: 

 <vcs_type>+<scheme>://<location>/<user_or_organization>/<repository>@<branch_or_tag>#<package_name>

La única sección opcional es la sección @<branch_or_tag> . Al usar git sobre SSH, puede usar la abreviatura vcs y el alias de esquema git+git@<location>:<user_or_organization>/<repository>@<branch_or_tag>#<package_name> . Tenga en cuenta que esto se traduce a git+ssh://git@<location> cuando se analiza.

Los valores válidos para <vcs_type> incluyen git , bzr , svn y hg . Los valores válidos para <scheme> incluyen http, , https , ssh y file . En casos específicos, también tiene acceso a otros esquemas: svn se puede combinar con svn como esquema y bzr se puede combinar con sftp y lp .

Tenga en cuenta que se recomienda encarecidamente instalar cualquier dependencia controlada por versión en modo editable, utilizando pipenv install -e , para garantizar que la resolución de dependencia se pueda realizar con una copia actualizada del repositorio cada vez que se realice, y que incluya todas las dependencias conocidas.

A continuación se muestra un ejemplo de uso que instala el repositorio de git ubicado en https://github.com/requests/requests.git desde la etiqueta v2.19.1 como requests de nombre de paquete: 

 $ pipenv install -e git+https://github.com/requests/[email protected]#egg=requests
Creating a Pipfile for this project...
Installing -e git+https://github.com/requests/[email protected]#egg=requests...
[...snipped...]
Adding -e git+https://github.com/requests/[email protected]#egg=requests to Pipfile's [packages]...
[...]

Puede leer más sobre la implementación de soporte de vcs por parte de pip aquí.

Instale una dependencia de desarrollo: 

 $ pipenv install pytest --dev
Installing pytest...
...
Adding pytest to Pipfile's [dev-packages]...

Mostrar un gráfico de dependencia: 

 $ pipenv graph
requests==2.18.4
  - certifi [required: >=2017.4.17, installed: 2017.7.27.1]
  - chardet [required: >=3.0.2,<3.1.0, installed: 3.0.4]
  - idna [required: >=2.5,<2.7, installed: 2.6]
  - urllib3 [required: <1.23,>=1.21.1, installed: 1.22]

Generar un archivo de bloqueo: 

 $ pipenv lock
Assuring all dependencies from Pipfile are installed...
Locking [dev-packages] dependencies...
Locking [packages] dependencies...
Note: your project now has only default [packages] installed.
To install [dev-packages], run: $ pipenv install --dev

Instale todas las dependencias de desarrollo: 

 $ pipenv install --dev
Pipfile found at /Users/kennethreitz/repos/kr/pip2/test/Pipfile. Considering this to be the project home.
Pipfile.lock out of date, updating...
Assuring all dependencies from Pipfile are installed...
Locking [dev-packages] dependencies...
Locking [packages] dependencies...

Desinstalar todo: 

 $ pipenv uninstall --all
No package provided, un-installing all dependencies.
Found 25 installed package(s), purging...
...
Environment now purged and fresh!

Usa el caparazón: 

 $ pipenv shell
Loading .env environment variables...
Launching subshell in virtual environment. Type 'exit' or 'Ctrl+D' to return.
$ ▯

OBJETIVO Y VENTAJAS DE PIPENV

Para comprender los problemas que resuelve Pipenv, resulta útil mostrar cómo ha evolucionado la gestión de paquetes de Python.

Regrese a la primera iteración de Python. Teníamos Python, pero no había una forma limpia de instalar paquetes.

Luego vino Easy Install, un paquete que instala otros paquetes de Python con relativa facilidad. Pero tenía un inconveniente: no era fácil desinstalar paquetes que ya no eran necesarios.

Ingrese pip, con el que la mayoría de los usuarios de Python están familiarizados. pip nos permite instalar y desinstalar paquetes. Podríamos especificar versiones, ejecutar pip congelar > requisitos.txt para generar una lista de paquetes instalados en un archivo de texto y usar ese mismo archivo de texto para instalar todo lo que una aplicación necesita con pip install -r requisitos.txt.

Pero pip no incluía una forma de aislar paquetes entre sí. Podríamos trabajar en aplicaciones que usan diferentes versiones de las mismas bibliotecas, por lo que necesitábamos una forma de habilitarlo.

Pipenv tiene como objetivo resolver varios problemas. Primero, el problema de necesitar la biblioteca pip para la instalación del paquete, más una biblioteca para crear un entorno virtual, más una biblioteca para administrar entornos virtuales, más todos los comandos asociados con esas bibliotecas. Eso es mucho que gestionar. Pipenv viene con administración de paquetes y soporte de entorno virtual, por lo que puede usar una herramienta para instalar, desinstalar, rastrear y documentar sus dependencias y crear, usar y organizar sus entornos virtuales. Cuando inicias un proyecto con él, Pipenv creará automáticamente un entorno virtual para ese proyecto si aún no estás usando uno.

Pipenv logra esta gestión de dependencia abandonando la norma requisitos.txt y cambiándola por un nuevo documento llamado Pipfile. Cuando instala una biblioteca con Pipenv, un archivo Pipfile para su proyecto se actualiza automáticamente con los detalles de esa instalación, incluida la información de la versión y posiblemente la ubicación del repositorio de Git, la ruta del archivo y otra información.

En segundo lugar, Pipenv quiere facilitar la gestión de interdependencias complejas.

El uso de Pipenv, que le brinda Pipfile, le permite evitar estos problemas al administrar las dependencias para diferentes entornos. Este comando instalará las principales dependencias del proyecto:

instalación de pipenv

Agregar la etiqueta --dev instalará los requisitos de desarrollo/pruebas:

pipenv install --dev Para generar un archivo Pipfile.lock, ejecute:

bloqueo de tubería

También puedes ejecutar scripts de Python con Pipenv. Para ejecutar un script Python de nivel superior llamado hello.py, ejecute:

pipenv ejecuta python hola.py

Y verá el resultado esperado en la consola.

Para iniciar un shell, ejecute:

cáscara de pipenv

Si desea convertir un proyecto que actualmente usa un archivo require.txt para usar Pipenv, instale Pipenv y ejecute:

requisitos de instalación de pipenv.txt

Esto creará un Pipfile e instalará los requisitos especificados.

Documentación

La documentación se encuentra en pipenv.pypa.io.

Historia de las estrellas

Expandir
Información adicional
Aplicaciones relacionadas
Recomendado para ti
Información relacionada Todo