Page d'accueil>Lié à la programmation>Python
Télécharger

Pipenv : workflow de développement Python pour les humains

Pipenv est un outil de gestion Python virtualenv qui prend en charge une multitude de systèmes et comble joliment les écarts entre pip, python (en utilisant le système python, pyenv ou asdf) et virtualenv. Linux, macOS et Windows sont tous des citoyens de premier ordre dans pipenv.

Pipenv crée et gère automatiquement un virtualenv pour vos projets, et ajoute/supprime des packages de votre Pipfile lorsque vous installez/désinstallez des packages. Il génère également un projet Pipfile.lock , qui est utilisé pour produire des builds déterministes.

Pipenv est principalement destiné à fournir aux utilisateurs et aux développeurs d'applications une méthode simple pour parvenir à un environnement de projet de travail cohérent.

Les problèmes que Pipenv cherche à résoudre sont multiformes :

  • Vous n'avez plus besoin d'utiliser pip et virtualenv séparément : ils fonctionnent ensemble.
  • La gestion d'un fichier requirements.txt avec des hachages de package peut être problématique. Pipenv utilise Pipfile et Pipfile.lock pour séparer les déclarations de dépendances abstraites de la dernière combinaison testée.
  • Les hachages sont documentés dans le fichier de verrouillage et vérifiés lors de l'installation. Les considérations de sécurité sont mises en avant.
  • Encouragez fortement l'utilisation des dernières versions des dépendances afin de minimiser les risques de sécurité résultant de composants obsolètes.
  • Vous donne un aperçu de votre graphique de dépendances (par exemple $ pipenv graph ).
  • Rationalisez le flux de travail de développement en prenant en charge les personnalisations locales avec les fichiers .env .

Table des matières

  • Pipenv

  • Installation

  • Caractéristiques

  • Concepts de base

  • Autres commandes

  • Achèvement de la coque

  • Usage

    • Exemples d'utilisation

    • Commandes

    • Localiser le projet

    • Localisez le virtualenv

    • Localisez l'interpréteur Python

    • Installer des packages

    • Installation depuis git

    • Installer une dépendance de développement

    • Afficher un graphique de dépendance

    • Générer un fichier de verrouillage

    • Installer toutes les dépendances de développement

    • Désinstallez tout

    • Utiliser la coque

  • Documentation

Installation

Pipenv peut être installé avec Python 3.7 et supérieur.

Pour la plupart des utilisateurs, nous recommandons d'installer Pipenv en utilisant pip : 

 pip install --user pipenv

Ou, si vous utilisez FreeBSD : 

 pkg install py39-pipenv

Ou, si vous utilisez Gentoo : 

 sudo emerge pipenv

Ou, si vous utilisez Void Linux : 

 sudo xbps-install -S python3-pipenv

Alternativement, certains utilisateurs préfèrent utiliser Pipx : 

 pipx install pipenv

Ou, certains utilisateurs préfèrent utiliser le module Python pip 

 python -m pip install pipenv

Reportez-vous à la documentation pour connaître les dernières instructions.

?

Caractéristiques

  • Permet des constructions véritablement déterministes , tout en spécifiant facilement uniquement ce que vous voulez .
  • Génère et vérifie les hachages de fichiers pour les dépendances verrouillées.
  • Installez automatiquement les Pythons requis, si pyenv ou asdf est disponible.
  • Trouve automatiquement la maison de votre projet, de manière récursive, en recherchant un Pipfile .
  • Génère automatiquement un Pipfile , s'il n'en existe pas.
  • Crée automatiquement un virtualenv dans un emplacement standard.
  • Ajoute/supprime automatiquement des packages à un Pipfile lorsqu'ils sont installés/désinstallés.
  • Charge automatiquement les fichiers .env , s'ils existent.

Pour obtenir une référence sur les commandes, voir Commandes.

Concepts de base

  • Un virtualenv sera automatiquement créé, lorsqu'il n'en existe pas.
  • Lorsqu'aucun paramètre n'est transmis à install , tous les packages [packages] spécifiés seront installés.
  • Sinon, la valeur par défaut de virtualenv sera la valeur par défaut.

Achèvement de la coque

Pour activer la complétion dans fish, ajoutez ceci à votre configuration ~/.config/fish/completions/pipenv.fish : 

 eval (env _PIPENV_COMPLETE=fish_source pipenv)

Il existe également un plugin fish, qui activera automatiquement vos sous-shells pour vous !

Alternativement, avec zsh, ajoutez ceci à votre configuration ~/.zshrc : 

 eval "$(_PIPENV_COMPLETE=zsh_source pipenv)"

Alternativement, avec bash, ajoutez ceci à votre configuration ~/.bashrc ou ~/.bash_profile : 

 eval "$(_PIPENV_COMPLETE=bash_source pipenv)"

Les complétions de coquilles magiques sont désormais activées !

Usage 

 $ 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.

Exemples d'utilisation : 

  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

Commandes : 

  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.

Localisez le projet : 

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

Localisez le virtualenv : 

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

Localisez l'interpréteur Python : 

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

Installer les packages : 

 $ 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

Installation depuis git :

Vous pouvez installer des packages avec pipenv depuis git et d'autres systèmes de contrôle de version en utilisant des URL formatées selon la règle suivante : 

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

La seule section facultative est la section @<branch_or_tag> . Lorsque vous utilisez git sur SSH, vous pouvez utiliser le raccourci vcs et l'alias de schéma git+git@<location>:<user_or_organization>/<repository>@<branch_or_tag>#<package_name> . Notez que ceci est traduit en git+ssh://git@<location> lors de l'analyse.

Les valeurs valides pour <vcs_type> incluent git , bzr , svn et hg . Les valeurs valides pour <scheme> incluent http, , https , ssh et file . Dans des cas spécifiques, vous avez également accès à d'autres schémas : svn peut être combiné avec svn en tant que schéma, et bzr peut être combiné avec sftp et lp .

Notez qu'il est fortement recommandé d'installer toutes les dépendances contrôlées par la version en mode modifiable, à l'aide de pipenv install -e , afin de garantir que la résolution des dépendances peut être effectuée avec une copie à jour du référentiel à chaque fois qu'elle est effectuée, et qu'il inclut toutes les dépendances connues.

Vous trouverez ci-dessous un exemple d'utilisation qui installe le référentiel git situé sur https://github.com/requests/requests.git à partir de la balise v2.19.1 en tant que requests de nom de package : 

 $ 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]...
[...]

Vous pouvez en savoir plus sur l'implémentation par pip du support vcs ici.

Installez une dépendance de développement : 

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

Afficher un graphique de dépendance : 

 $ 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]

Générez un fichier de verrouillage : 

 $ 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

Installez toutes les dépendances de développement : 

 $ 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...

Désinstallez tout : 

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

Utilisez le shell : 

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

OBJECTIF ET AVANTAGES DU PIPENV

Pour comprendre les problèmes résolus par Pipenv, il est utile de montrer comment la gestion des packages Python a évolué.

Revenez à la première itération de Python. Nous avions Python, mais il n'existait aucun moyen propre d'installer des packages.

Puis est venu Easy Install, un package qui installe d’autres packages Python avec une relative facilité. Mais il y avait un problème : il n'était pas facile de désinstaller les paquets qui n'étaient plus nécessaires.

Entrez pip, que la plupart des utilisateurs de Python connaissent. pip nous permet d'installer et de désinstaller des packages. Nous pourrions spécifier des versions, exécuter pip freeze > Requirements.txt pour afficher une liste des packages installés dans un fichier texte et utiliser ce même fichier texte pour installer tout ce dont une application a besoin avec pip install -r Requirements.txt.

Mais pip n'incluait pas de moyen d'isoler les packages les uns des autres. Nous pourrions travailler sur des applications qui utilisent différentes versions des mêmes bibliothèques, nous avions donc besoin d'un moyen de l'activer.

Pipenv vise à résoudre plusieurs problèmes. Premièrement, le problème de la nécessité de la bibliothèque pip pour l'installation du package, plus une bibliothèque pour créer un environnement virtuel, plus une bibliothèque pour gérer les environnements virtuels, ainsi que toutes les commandes associées à ces bibliothèques. Cela fait beaucoup à gérer. Pipenv est livré avec la gestion des packages et la prise en charge de l'environnement virtuel, vous pouvez donc utiliser un seul outil pour installer, désinstaller, suivre et documenter vos dépendances et pour créer, utiliser et organiser vos environnements virtuels. Lorsque vous démarrez un projet avec, Pipenv créera automatiquement un environnement virtuel pour ce projet si vous n'en utilisez pas déjà un.

Pipenv réalise cette gestion des dépendances en abandonnant la norme Requirements.txt et en l'échangeant contre un nouveau document appelé Pipfile. Lorsque vous installez une bibliothèque avec Pipenv, un Pipfile pour votre projet est automatiquement mis à jour avec les détails de cette installation, y compris les informations de version et éventuellement l'emplacement du référentiel Git, le chemin du fichier et d'autres informations.

Deuxièmement, Pipenv souhaite faciliter la gestion des interdépendances complexes.

L'utilisation de Pipenv, qui vous fournit Pipfile, vous permet d'éviter ces problèmes en gérant pour vous les dépendances de différents environnements. Cette commande installera les principales dépendances du projet :

installation de pipenv

L'ajout de la balise --dev installera les exigences de développement/test :

pipenv install --dev Pour générer un fichier Pipfile.lock, exécutez :

verrouillage pipenv

Vous pouvez également exécuter des scripts Python avec Pipenv. Pour exécuter un script Python de niveau supérieur appelé hello.py, exécutez :

pipenv exécute python hello.py

Et vous verrez votre résultat attendu dans la console.

Pour démarrer un shell, exécutez :

shell pipenv

Si vous souhaitez convertir un projet qui utilise actuellement un fichier Requirements.txt pour utiliser Pipenv, installez Pipenv et exécutez :

exigences d'installation de pipenv.txt

Cela créera un Pipfile et installera les exigences spécifiées.

Documentation

La documentation réside sur pipenv.pypa.io.

Histoire des étoiles

Développer
Informations supplémentaires
Applications connexes
Recommandé pour vous
Actualités connexes Tout