Czy można używać toksyny z instalacjami Python opartymi na conda?

Question

Narzędzie do testowania Pythona tox wydaje się być zaprojektowane do pracy z virtualenv. Czy może również działać w instalacjach Python opartych na systemach conda/anaconda?

Answer 1

Podczas gdy tox nie może korzystać z conda, możesz użyć conda do "zainstalowania" różnych wersji Pythona, gdzie tox może je znaleźć (tak, jakby znalazł "normalne" instalacje Pythona w tych folderach). Poniżej znajduje przetestowany na Windows:

1. Trzeba virtualenv zainstalowane poprzez pip w środowisku korzeń Conda. Podejrzewam, że jest to virtualenv, który będzie użyty przez tox. (Musiałem zainstalować virtualenv przy użyciu pip install virtualenv, aby uzyskać polecenie virtualenv do pracy, mimo że conda list pokazał je jako zainstalowane.)
2. Zainstaluj wersje Pythona, które chcesz przetestować. Można to łatwo zrobić za pomocą conda create. tox wykryje pliki binarne Pythona na Windows w C:\python27, C:\python33 itp, więc tworzenie środowisk użyciu conda create -p C:\python27 python=2.7 itp

Answer 2

Nie wiem, jak to jest rozwinięte, ale można spojrzeć na https://github.com/hayd/ctox.

Answer 3

Tak, potrzebna jest zainstalowana wersja warunkowa virtualenv, aby to działało.

Spróbuj:

>conda install virtualenv

virtualenv    15.1.0     py36_ 

Przejdź do katalogu projektu zawierającego tox.ini

>tox

Answer 4

zrobiłem tox i Conda współpracować w Windows przez:

• Instalacja virtualenv z Conda w środowisku, które używam tox:

  conda install virtualenv

• Tworzenie "Spisie skrzyżowaniu" symlinks z C: \ PythonXY do mojego rzeczywistej ścieżki środowiska. To dostaje wokół InterpreterNotFound -error:

  mklink /J C:\PythonXY C:\real\path\to\myPythonXYenv

Mam zainstalowany Anaconda w E: \ Anaconda3 \, a wszystkie moje otoczenie w E: \ Anaconda3 \ envs \, np E: \ Anaconda3 \ envs \ py27 \

(Zobacz poniżej, aby uzyskać script, aby było to szybkie i łatwe.)

Krok 1 - Tworzenie środowiska z Conda:

E:\dev> conda create -n py27 python=2.7 --yes 
E:\dev> conda create -n py33 python=3.3 --yes 
... 
E:\dev> conda create -n py36 python=3.6 --yes 

Krok 2 - Tworzenie wszystkie dowiązania:

E:\dev> mklink /J C:\Python27 E:\Anaconda3\envs\py27 
E:\dev> mklink /J C:\Python33 E:\Anaconda3\envs\py33 
... 
E:\dev> mklink /J C:\Python36 E:\Anaconda3\envs\py36 

Uwaga: nazywam conda create z katalogu E-drive, więc opcja --prefix/-p nie jest wymagana w celu zainstalowania nowego środowiska ts w E: \ Anaconda3 \ envs \.

prostszy sposób:

Zamiast iść przez uciążliwego procesu ustawiania to dla każdej wersji środowiska/python, można użyć ToxEnvMatcher -class dodaje dalej w ten sposób:

my_envs = os.path.join('E:\\', 'Anaconda3', 'envs') 
tem = ToxEnvMatcher(my_envs) 
for version in '27,34,35,36'.split(','): 
    tem.make(version) 

Edit: aby skrypt łatwiejszy w obsłudze, Dodałem nową sekcję do file (tu zakłada się tox_with_conda.py,), więc to może być wywoływana z cmd.exe:

C:\dev> python tox_with_conda.py E:\Anaconda3\envs 27 34 35 36 37 

Używam Python 3.6.3 i 2.9.1 tox, ale nie wiem, kiedy/jeśli wcześniejsze wersje działają zbyt.

obrony: Przypuszczam, że dla niektórych, wydaje się to zbyt kłopotliwe procesu (to naprawdę nie jest, choć), albo znacznie hack. Należy jednak pamiętać, że możliwość używania Anacondy/Conda również zmniejsza stratę czasu spędzonego na instalowaniu bibliotek, pakietów, ++++.

Uwaga:

• używam Tox z pytest, i nie zauważyłem żadnych skutków dla moich testów.
• Moje testy są proste i istnieje szansa, że ​​nie mam jeszcze problemów.
• Zakładamy, że są rzeczy, o których nie pomyślałem, że mogą mieć znaczenie dla innych.

---

Klasa (dostępne także here):

from subprocess import run 
from os.path import join 

from sphinx.addnodes import desc 

DEFAULT_BASE = join('C:\\', 'Python') 


class ToxEnvMatcher: 
    """ 
    Utility to make conda environments work with tox. 

    Conda envs might be in other locations than where `tox <https://tox.readthedocs.io>`_ expects them to be. 

    A symbolic link 'Directory Junction' is created from expected location to the actual location. 
    Intended for Windows to get around the ``InterpreterNotFound``-error. 

    E.g.: tox expects to find Python 2.7 in ``C:\Python27``, 
    but may actually be installed in another drive and location. 

    Examples of use: 

    .. code-block:: python 

     my_envs = join('E:\\', 'Anaconda3', 'envs') 
     tem = ToxEnvMatcher(my_envs) 
     for version in '27,34,35,36'.split(','): 
      tem.make(version) 

    The class is utilized through ``argsparse`` so it can also be used from cmd.exe. 

    Examples of use of th of using ``ToxEnvMatcher`` from cmd.exe: 

    .. code-block:: none 

     E:\dev> tox_with_conda.py E:\Anaconda3\envs 27 34 35 36 37 

    It's possible to use the ``-b``/``--base`` option to override the default base location (``C:\Python``): 

    .. code-block:: none 

     E:\dev> tox_with_conda.py E:\Anaconda3\envs 27 34 35 36 37 --base D:\Python 

    :param str envs_dir: The path to where new conda environments will be created 
    :param str default_base: The base of the 'default' location. Usually it's ``C:\Python`` 
    """ 
    def __init__(self, envs_dir, default_base=DEFAULT_BASE): 
     self.envs_dir = envs_dir 
     self.default_base = default_base 

    def __repr__(self): 
     return '{}({})'.format(self.__class__.__name__, self.envs_dir) 

    def make(self, version): 
     """ 
     Take version and create conda environment with symlink from 'default tox location'. 

     E.g.: given version='27' and environment folder ``{self.envs_dir}``: 

     - ``conda create -p {self.envs_dir}\py27 python=2.7`` 
     - ``mklink /J C:\Python27 {self.envs_dir}\py27`` 

     :param str version: A string on the form 'XY', e.g. '27' or '36' 
     :return: None 
     :rtype: NoneType 
     """ 
     if len(version) != 2 or not int(version): 
      raise ValueError("Parameter 'version' must be on the form 'XY', and not '{}'".format(version)) 
     conda_cmd = self._create_cmd_args(version) 
     symlink_cmd = self._create_symlink_args(version) 
     run(conda_cmd, shell=True) 
     run(symlink_cmd, shell=True) 

    def _get_env_folder(self, version): 
     return join(self.envs_dir, 'py{}'.format(version)) 

    def _create_cmd_args(self, version): 
     env_dir = self._get_env_folder(version) 
     python_version = '.'.join(version) 
     conda_create = 'conda create -p {} python={} --yes'.format(env_dir, python_version) 
     return conda_create.split(' ') 

    def _create_symlink_args(self, version): 
     env_dir = self._get_env_folder(version) 
     return 'mklink /J {}{} {}'.format(self.default_base, version, env_dir).split(' ') 

Kod dodany do wytwarzania pracować z cmd to:

if __name__ == '__main__': 
    import argparse 

    parser = argparse.ArgumentParser() 
    parser.add_argument("env_dir", 
         help="The folder where conda environments should be installed.") 
    parser.add_argument("versions", nargs='*', 
         help="The list of versions, formatted 'XY' where X is major and Y minor. E.g. '27 35 36'") 
    parser.add_argument("-b", "--base", default=DEFAULT_BASE, 
         help="Base of the path which tox expects to find Python installed. " 
          "Default: {}.".format(DEFAULT_BASE)) 
    args = parser.parse_args() 

    print('env_dir: ', args.env_dir) 
    print('versions: ', args.versions) 
    print('--base: ', args.base) 

    tem = ToxEnvMatcher(args.env_dir, default_base=args.base) 
    for version in args.versions: 
     tem.make(version)