Lorsque, dans un virtualenv le code personnalisé aller?

Ce genre de structure de répertoire doit-on suivre lors de l'utilisation de virtualenv? Par exemple, si j'ai été de construire une application WSGI et créé un virtualenv appelé foobar je voudrais commencer par une structure de répertoire:

/foobar
  /bin
    {activate, activate.py, easy_install, python}
  /include
    {python2.6/...}
  /lib
    {python2.6/...}

Une fois cet environnement est créé, où serait-on dans un lieu qui leur est propre:

fichiers python?
des fichiers statiques (images, etc)?
"personnalisé" paquets, tels que ceux disponibles en ligne, mais pas trouvé dans le fromage-shop?

par rapport à la virtualenv répertoires?

(À supposer que je sais déjà où le virtualenv répertoires eux-mêmes devrait aller.)

Je suis en désaccord. Comment vous disposition une application python est une question distincte de la façon dont vous recherchez l'application dans un virtualenv à des fins de développement. C'est lié, mais pas la même. Merci de ne pas fermer les doublons.

InformationsquelleAutor Phillip B Oldham | 2009-11-23

81

virtualenv fournit un interpréteur python, par exemple, pas une instance de l'application. Vous n'auriez pas normalement créer les fichiers de votre application dans les répertoires contenant un système par défaut de Python, de même il n'y a aucune exigence pour localiser votre demande dans un virtualenv répertoire.

Par exemple, vous pourriez avoir un projet pour lequel vous disposez de plusieurs applications utilisant la même virtualenv. Ou, vous avez peut-être tester une application avec un virtualenv qui sera par la suite déployé avec un système de Python. Ou, vous avez peut-être empaquetage d'une application autonome où il pourrait être utile d'avoir le virtualenv répertoire situé quelque part dans le répertoire app elle-même.

Donc, en général, je ne pense pas qu'il y est une seule bonne réponse à la question. Et, une bonne chose à propos de virtualenv est qu'il prend en charge de nombreux différents cas d'utilisation: il n'a pas besoin d'être un droit chemin.
- D'accord. J'utilise virtualenv pour tout ce que je fais, et je n'ai jamais placer les fichiers à l'intérieur de la virtualenv répertoire. Virtualenv besoin n'ont aucun impact sur votre projet de la structure; il suffit d'activer le virtualenv (ou d'utiliser ses bin/python), et de travailler sur vos fichiers où que vous auriez de toute façon.
- J'ai aussi tout à fait d'accord. La seule fois où j' jamais toucher tous les fichiers à l'intérieur de mon virtualenv (j'utilise virtualenvwrapper), c'est quand je veux modifier la postactivate et postdeactivate crochets.
- La Question serait mieux servi avec du béton, des exemples concrets de différentes options, y compris des échanges comme on le voit dans d'autres réponses à cette question.
- Il est plus propre à maintenir votre projet distinct de la virtualenv répertoire, mais en comparant virtualenv de système de python est inutile, parce que le but de virtualenv est de fixer des dépendances cassées et d'isoler les projets, de sorte qu'ils peuvent utiliser différentes versions de package et même les versions de python (je me rends compte que ceci a été écrit avant python3). Permettant aux applications de partager un virtualenv est à l'aide de virtualenv comme si c'était le système de python, en laissant les applications vulnérables aux mêmes questions virtualenv est conçu pour les résoudre. There should be one obvious way to do it , logiquement cela devrait être de 1:1
- En essayant d'acquérir un certain nombre de meilleures pratiques, mais il est encore difficile: si vous avez des dizaines de projets, chacun avec son propre virtualenv alors comment voulez-vous garder une trace de la projet est utilisé avec qui virtualenv? Ajouter minuscule scripts shell dans la racine de chaque dossier avec le nom de la virtualenv vous l'utilisez avec?
InformationsquelleAutor Ned Deily
53

Si vous n'avez que quelques projets de chaque tellement souvent, rien ne vous empêche de créer un nouveau virtualenv pour chacun d'eux, et de mettre vos paquets à l'intérieur:
```
/foobar
  /bin
    {activate, activate.py, easy_install, python}
  /include
    {python2.6/...}
  /lib
    {python2.6/...}
  /mypackage1
    __init__.py
  /mypackage2
    __init__.py
```
L'avantage de cette approche est que vous pouvez toujours être sûr de trouver des trouver des les activer script qui appartient à la projet à l'intérieur.
```
$ cd /foobar
$ source bin/activate
$ python 
>>> import mypackage1
>>>
```
Si vous décidez d'être un peu plus organisé, vous devriez envisager de mettre tous vos virtualenvs dans un dossier, et le nom de chacun d'eux après le projet sur lequel vous travaillez.
```
  /virtualenvs
    /foobar
      /bin
        {activate, activate.py, easy_install, python}
      /include
        {python2.6/...}
      /lib
        {python2.6/...}
  /foobar
    /mypackage1
      __init__.py
    /mypackage2
      __init__.py
```
De cette façon, vous pouvez toujours recommencer avec une nouvelle virtualenv quand les choses vont mal, et vos fichiers de projet à rester en sécurité.

Un autre avantage est que plusieurs de vos projets peuvent utiliser le même virtualenv, de sorte que vous n'avez pas à faire la même installation de plus de et plus si vous avez beaucoup de dépendances.
```
$ cd /foobar
$ source ../virtualenvs/foobar/bin/activate
$ python 
>>> import mypackage2
>>>
```
Pour les utilisateurs qui ont régulièrement à installer et à démonter virtualenvs il serait judicieux de regarder à virtualenvwrapper.
```
http://pypi.python.org/pypi/virtualenvwrapper
```
Avec virtualenvwrapper vous pouvez
```
* create and delete virtual environments

* organize virtual environments in a central place

* easily switch between environments
```
Vous ne plus avoir à vous soucier de l'endroit où votre virtualenvs sont lorsque vous travaillez sur des projets "foo" et "bar":
```
  /foo
    /mypackage1
      __init__.py
  /bar
    /mypackage2
      __init__.py
```
C'est une façon de commencer à travailler sur le projet "foo":
```
$ cd foo
$ workon
bar
foo
$ workon foo
(foo)$ python
>>> import mypackage1
>>>
```
Puis en passant au projet "bar" est aussi simple que cela:
```
$ cd ../bar
$ workon bar
(bar)$ python
>>> import mypackage2
>>>
```
Assez soignée, n'est-ce pas?
- J' fortement d'accord avec cette réponse sur l'utilisation de virtualenvwrapper. Il parfaitement résumés de la virtualenv loin tout en vous offrant tous les avantages.
- Mais vivement en désaccord à propos de JAMAIS, de mettre votre code à l'intérieur de l'environnement virtuel. Si vous le voulez "près" du projet sur le système de fichiers puis mettre un venv/ répertoire au même niveau que le projet de BASE_DIR.
InformationsquelleAutor Maik Röder
28

Parce que virtualenvs ne sont pas délocalisables, à mon avis c'est une mauvaise pratique de placer vos fichiers de projet à l'intérieur d'un virtualenv répertoire. Le virtualenv lui-même est un générés développement/déploiement de l'artefact (un peu comme un .pyc fichier), ne fait pas partie du projet; il devrait être facile de l'emporter et de le recréer à tout moment, ou en créer un nouveau sur une nouvelle déployer d'accueil, etc.

Beaucoup de gens en fait, l'utilisation de virtualenvwrapper, qui supprime le réel virtualenvs de votre conscience presque complètement, en les plaçant tous les côte-à-côte dans $HOME/.virtualenvs par défaut.
- Complètement d'accord que c'est une mauvaise pratique, la grande au point qu'il devrait être facile de souffler et de la recréer, notamment pour tester les déploiements et grignotage unneeding exigences de paquets. Tiens juste à ajouter que virtualenv est possible de déplacer à l'aide par exemple virtualenv --relocatable myvenv voir stackoverflow.com/a/6628642/1335793 tout simplement parce que vous pouvez ne signifie pas que vous devriez bien.
InformationsquelleAutor Carl Meyer
2

Si vous donner à votre projet une setup.py, pep, vous pouvez l'importer à partir de la version de contrôle directement.

Faire quelque chose comme ceci:
```
$ virtualenv --no-site-packages myproject
$ . myproject/bin/activate
$ easy_install pip
$ pip install -e hg+http://bitbucket.org/owner/myproject#egg=proj
```
La -e va mettre le projet en myproject/src, mais le lien de myproject/lib/pythonX.X/site-packages/, afin que toutes les modifications que vous apportez seront ramassés immédiatement dans des modules que l'importer à partir de votre local site-packages. Le #egg bit indique pip quel nom que vous souhaitez donner à l'œuf paquet qu'elle crée pour vous.

Si vous n'utilisez pas --no-site-packages, veillez à spécifier que vous souhaitez pip à installer dans le virtualenv avec le -E option

InformationsquelleAutor jcdyer

Vous devez vous connecter pour publier un commentaire.