def check(dirname):
env_var = conda_api.conda_prefix_variable()
try:
_push_fake_env_creator()
project = Project(dirname)
environ = minimal_environ()
result = prepare_without_interaction(project,
environ=environ,
env_spec_name='foo')
expected_path = project.env_specs['foo'].path(
project.directory_path)
assert result.environ[env_var] == expected_path
environ = minimal_environ()
result = prepare_without_interaction(project,
environ=environ,
env_spec_name='bar')
assert result.errors == []
assert result
expected_path = project.env_specs['bar'].path(
project.directory_path)
assert result.environ[env_var] == expected_path
finally:
_pop_fake_env_creator()
def missing_env_vars_to_configure(self, requirement, environ,
local_state_file):
"""Override superclass to require env prefix."""
if self._get_env_prefix(environ) is not None:
return ()
else:
return (conda_api.conda_prefix_variable(), )
def __init__(self, registry, env_specs=None):
"""Extend superclass to default to CONDA_PREFIX and carry environment information.
Args:
registry (RequirementsRegistry): plugin registry
env_specs (dict): dict from env name to ``CondaEnvironment``
"""
super(CondaEnvRequirement,
self).__init__(registry=registry,
env_var=conda_api.conda_prefix_variable())
self.env_specs = env_specs
self._conda = new_conda_manager()
def exec_info_for_environment(self, environ, extra_args=None):
"""Get a ``CommandExecInfo`` ready to be executed.
Args:
environ (dict): the environment containing a CONDA_PREFIX, PATH, and PROJECT_DIR
extra_args (list of str): extra args to append to the command line
Returns:
argv as list of strings
"""
conda_var = conda_api.conda_prefix_variable()
for name in (conda_var, 'PATH', 'PROJECT_DIR'):
if name not in environ:
raise ValueError(
"To get a runnable command for the app, %s must be set." %
(name))
(args, shell) = self._choose_args_and_shell(environ, extra_args)
if args is None:
# command doesn't work on our platform for example
return None
# always look in the project directory. This is a little
# odd because we don't add PROJECT_DIR to PATH for child
# processes - maybe we should?
path = os.pathsep.join([environ['PROJECT_DIR'], environ['PATH']])
# if we're using a shell, then args[0] is a whole command
# line and not a single program name, and the shell will
# search the path for us.
if not shell:
executable = spawn.find_executable(args[0], path)
# if we didn't find args[0] on the path, we leave it as-is
# and wait for it to fail when we later try to run it.
if executable is not None:
# if the executable is in cwd, for some reason spawn.find_executable does not
# return the full path to it, just a relative path.
args[0] = os.path.abspath(executable)
# conda.misc.launch() uses the home directory
# instead of the project directory as cwd when
# running an installed package, but for our
# purposes where we know we have a project dir
# that's user-interesting, project directory seems
# more useful. This way apps can for example find
# sample data files relative to the project
# directory.
return CommandExecInfo(cwd=environ['PROJECT_DIR'],
args=args,
env=environ,
shell=shell)
def check(dirname):
env_var = conda_api.conda_prefix_variable()
try:
_push_fake_env_creator()
project = Project(dirname)
environ = minimal_environ()
# we specify the command name but not the
# env_spec_name but it should imply the proper env
# spec name.
result = prepare_without_interaction(project, environ=environ, command_name='hello')
expected_path = project.env_specs['foo'].path(project.directory_path)
assert result.environ[env_var] == expected_path
finally:
_pop_fake_env_creator()
def test_conda_variable_when_have_all_three(monkeypatch):
monkeypatch.setattr(
'os.environ',
dict(CONDA_ENV_PATH='foo', CONDA_DEFAULT_ENV='bar',
CONDA_PREFIX='baz'))
assert conda_api.conda_prefix_variable() == 'CONDA_PREFIX'
def test_conda_variable_when_have_only_default_env(monkeypatch):
monkeypatch.setattr('os.environ', dict(CONDA_DEFAULT_ENV='foo'))
assert conda_api.conda_prefix_variable() == 'CONDA_DEFAULT_ENV'
def test_conda_variable_when_not_in_conda(monkeypatch):
monkeypatch.setattr('os.environ', dict())
assert conda_api.conda_prefix_variable() == 'CONDA_PREFIX'
from anaconda_project.internal.test.test_conda_api import monkeypatch_conda_not_to_use_links
from anaconda_project.prepare import (prepare_without_interaction,
prepare_in_stages, unprepare)
from anaconda_project.project_file import DEFAULT_PROJECT_FILENAME
from anaconda_project.project import Project
from anaconda_project import provide
from anaconda_project.requirements_registry.registry import RequirementsRegistry
from anaconda_project.requirements_registry.providers.conda_env import CondaEnvProvider
from anaconda_project.requirements_registry.requirements.conda_env import CondaEnvRequirement
if platform.system() == 'Windows':
script_dir = "Scripts"
else:
script_dir = "bin"
conda_env_var = conda_api.conda_prefix_variable()
def test_find_by_class_name_conda_env():
registry = RequirementsRegistry()
found = registry.find_provider_by_class_name(class_name="CondaEnvProvider")
assert found is not None
assert isinstance(found, CondaEnvProvider)
@pytest.mark.slow
def test_prepare_and_unprepare_project_scoped_env(monkeypatch):
monkeypatch_conda_not_to_use_links(monkeypatch)
def prepare_project_scoped_env(dirname):
project = Project(dirname)
# -*- coding: utf-8 -*-
# ----------------------------------------------------------------------------
# Copyright © 2016, Continuum Analytics, Inc. All rights reserved.
#
# The full license is in the file LICENSE.txt, distributed with this software.
# ----------------------------------------------------------------------------
from __future__ import absolute_import, print_function
from anaconda_project.internal.cli.variable_commands import main_add, main_remove
from anaconda_project.internal.cli.main import _parse_args_and_run_subcommand
from anaconda_project.internal.test.tmpfile_utils import with_directory_contents_completing_project_file
from anaconda_project.internal.simple_status import SimpleStatus
from anaconda_project.internal import conda_api
from anaconda_project.project_file import DEFAULT_PROJECT_FILENAME
PLATFORM_ENV_VAR = conda_api.conda_prefix_variable()
class Args(object):
def __init__(self,
vars_to_add=None,
vars_to_remove=None,
directory='.',
default=None,
env_spec=None):
self.directory = directory
self.vars_to_add = vars_to_add
self.vars_to_remove = vars_to_remove
self.default = None
self.env_spec = None
def _get_env_prefix(self, environ):
# on unix, ENV_PATH is the prefix and DEFAULT_ENV can be just a name,
# on windows DEFAULT_ENV is always the prefix
return environ.get(conda_api.conda_prefix_variable(), None)
def exec_info_for_environment(self, environ, extra_args=None):
"""Get a ``CommandExecInfo`` ready to be executed.
Args:
environ (dict): the environment containing a CONDA_PREFIX, PATH, and PROJECT_DIR
extra_args (list of str): extra args to append to the command line
Returns:
argv as list of strings
"""
conda_var = conda_api.conda_prefix_variable()
for name in (conda_var, 'PATH', 'PROJECT_DIR'):
if name not in environ:
raise ValueError(
"To get a runnable command for the app, %s must be set." %
(name))
(args, shell) = self._choose_args_and_shell(environ, extra_args)
if args is None:
# command doesn't work on our platform for example
return None
# always look in the project directory. This is a little
# odd because we don't add PROJECT_DIR to PATH for child
# processes - maybe we should?
path = os.pathsep.join([environ['PROJECT_DIR'], environ['PATH']])
# if we're using a shell, then args[0] is a whole command
# line and not a single program name, and the shell will
# search the path for us.
if not shell:
# We used to use spawn.find_executable but it is not
# consistent across platforms. Specifically, for Windows
# it seems to insist unnecessarily on an .exe extension
# (unnecessary for our purposes at least)
extensions = ['', '.bat', '.exe'] if _is_windows() else ['']
executable = None
for pdir in path.split(os.pathsep):
for ext in extensions:
fpath = os.path.join(pdir, args[0] + ext)
if os.path.exists(fpath):
executable = fpath
break
if executable is not None:
args[0] = os.path.abspath(executable)
break
# if we didn't find args[0] on the path, we leave it as-is
# and wait for it to fail when we later try to run it.
# conda.misc.launch() uses the home directory
# instead of the project directory as cwd when
# running an installed package, but for our
# purposes where we know we have a project dir
# that's user-interesting, project directory seems
# more useful. This way apps can for example find
# sample data files relative to the project
# directory.
return CommandExecInfo(cwd=environ['PROJECT_DIR'],
args=args,
env=environ,
shell=shell)