def check(dirname):
project = project_no_dedicated_env(dirname)
environ = minimal_environ()
result = prepare_without_interaction(project, environ=environ, command_name='foo')
assert result
assert result.command_exec_info.bokeh_app == 'foo.py'
environ = minimal_environ()
result = prepare_without_interaction(project, environ=environ, command_name='bar')
assert result
assert result.command_exec_info.bokeh_app == 'bar.py'
def check(dirname):
project = project_no_dedicated_env(dirname)
environ = minimal_environ()
result = prepare_without_interaction(project, environ=environ, command_name='foo')
assert result
assert os.path.join(project.directory_path, 'foo.py') in result.command_exec_info.args
environ = minimal_environ()
result = prepare_without_interaction(project, environ=environ, command_name='bar')
assert result
assert os.path.join(project.directory_path, 'bar.py') in result.command_exec_info.args
def unprepare_empty(dirname):
project = project_no_dedicated_env(dirname)
environ = minimal_environ()
result = prepare_without_interaction(project, environ=environ)
assert result
status = unprepare(project, result)
assert status
def provide_download_of_zip(zipname, dirname):
with codecs.open(os.path.join(dirname, DEFAULT_PROJECT_FILENAME), 'w', 'utf-8') as f:
f.write(complete_project_file_content(ZIPPED_DATAFILE_CONTENT_CHECKSUM))
@gen.coroutine
def mock_downloader_run(self, loop):
class Res:
pass
res = Res()
res.code = 200
assert self._url.endswith(".zip")
assert self._filename.endswith(".zip")
shutil.copyfile(zipname, self._filename)
self._hash = '12345abcdef'
raise gen.Return(res)
monkeypatch.setattr("conda_kapsel.internal.http_client.FileDownloader.run", mock_downloader_run)
project = project_no_dedicated_env(dirname)
result = prepare_without_interaction(project, environ=minimal_environ(PROJECT_DIR=dirname))
assert hasattr(result, 'environ')
assert 'DATAFILE' in result.environ
assert os.path.isdir(os.path.join(dirname, 'data'))
assert os.path.isfile(os.path.join(dirname, 'data', 'foo'))
assert codecs.open(os.path.join(dirname, 'data', 'foo')).read() == 'hello\n'
status = unprepare(project, result)
filename = os.path.join(dirname, 'data')
assert status.logs == ["Removed downloaded file %s." % filename,
("Current environment is not in %s, no need to delete it." % dirname)]
assert status.status_description == "Success."
def prepare_some_env_var(dirname):
project = project_no_dedicated_env(dirname)
environ = minimal_environ(FOO='bar')
result = prepare_without_interaction(project, environ=environ)
assert result
assert dict(FOO='bar', PROJECT_DIR=project.directory_path) == strip_environ(result.environ)
assert dict(FOO='bar') == strip_environ(environ)
def provide_download_of_zip_no_unzip(zipname, dirname):
with codecs.open(os.path.join(dirname, DEFAULT_PROJECT_FILENAME), 'w', 'utf-8') as f:
f.write(complete_project_file_content(ZIPPED_DATAFILE_CONTENT_NO_UNZIP))
@gen.coroutine
def mock_downloader_run(self, loop):
class Res:
pass
res = Res()
res.code = 200
assert self._url.endswith(".zip")
# we aren't going to unzip so we should be downloading straignt to
# the specified filename 'data' without the .zip on it
assert not self._filename.endswith(".zip")
shutil.copyfile(zipname, self._filename)
raise gen.Return(res)
monkeypatch.setattr("conda_kapsel.internal.http_client.FileDownloader.run", mock_downloader_run)
project = project_no_dedicated_env(dirname)
result = prepare_without_interaction(project, environ=minimal_environ(PROJECT_DIR=dirname))
assert hasattr(result, 'environ')
assert 'DATAFILE' in result.environ
assert os.path.isfile(os.path.join(dirname, 'data'))
with zipfile.ZipFile(os.path.join(dirname, 'data')) as zf:
assert zf.namelist() == ['foo']
def provide_download_of_zip(zipname, dirname):
with codecs.open(os.path.join(dirname, DEFAULT_PROJECT_FILENAME), 'w', 'utf-8') as f:
f.write(complete_project_file_content(ZIPPED_DATAFILE_CONTENT_NO_ZIP_SUFFIX))
@gen.coroutine
def mock_downloader_run(self, loop):
class Res:
pass
res = Res()
res.code = 200
# we add .zip to the download filename, even though it wasn't in the URL
assert not self._url.endswith(".zip")
assert self._filename.endswith(".zip")
shutil.copyfile(zipname, self._filename)
raise gen.Return(res)
monkeypatch.setattr("conda_kapsel.internal.http_client.FileDownloader.run", mock_downloader_run)
project = project_no_dedicated_env(dirname)
result = prepare_without_interaction(project, environ=minimal_environ(PROJECT_DIR=dirname))
assert hasattr(result, 'environ')
assert 'DATAFILE' in result.environ
assert os.path.isdir(os.path.join(dirname, 'data'))
assert os.path.isfile(os.path.join(dirname, 'data', 'foo'))
assert codecs.open(os.path.join(dirname, 'data', 'foo')).read() == 'hello\n'
def provide_download_of_zip(dirname):
with codecs.open(os.path.join(dirname, DEFAULT_PROJECT_FILENAME), 'w', 'utf-8') as f:
f.write(complete_project_file_content(ZIPPED_DATAFILE_CONTENT))
@gen.coroutine
def mock_downloader_run(self, loop):
class Res:
pass
res = Res()
res.code = 200
assert self._url.endswith(".zip")
assert self._filename.endswith(".zip")
with codecs.open(self._filename, 'w', 'utf-8') as f:
f.write("This is not a zip file.")
raise gen.Return(res)
monkeypatch.setattr("conda_kapsel.internal.http_client.FileDownloader.run", mock_downloader_run)
project = project_no_dedicated_env(dirname)
result = prepare_without_interaction(project, environ=minimal_environ(PROJECT_DIR=dirname))
assert not result
assert [("Failed to unzip %s: File is not a zip file" % os.path.join(dirname, "data.zip")),
"missing requirement to run this project: A downloaded file which is referenced by DATAFILE.",
" Environment variable DATAFILE is not set."] == result.errors
def provide_download(dirname):
@gen.coroutine
def mock_downloader_run(self, loop):
class Res:
pass
res = Res()
res.code = 200
with open(os.path.join(dirname, 'data.csv'), 'w') as out:
out.write('data')
self._hash = '12345abcdef'
raise gen.Return(res)
monkeypatch.setattr("conda_kapsel.internal.http_client.FileDownloader.run", mock_downloader_run)
project = project_no_dedicated_env(dirname)
result = prepare_without_interaction(project, environ=minimal_environ(PROJECT_DIR=dirname))
assert hasattr(result, 'environ')
assert 'DATAFILE' in result.environ
filename = os.path.join(dirname, 'data.csv')
assert os.path.exists(filename)
status = unprepare(project, result)
assert status.logs == ["Removed downloaded file %s." % filename,
("Current environment is not in %s, no need to delete it." % dirname)]
assert status.status_description == 'Success.'
assert status
assert not os.path.exists(filename)
def prepare_some_env_var(dirname):
project = project_no_dedicated_env(dirname)
environ = minimal_environ(FOO='bar')
result = prepare_without_interaction(project, environ=environ)
assert result
assert dict(FOO='bar', PROJECT_DIR=project.directory_path) == strip_environ(result.environ)
assert dict(FOO='bar') == strip_environ(environ)
def check(dirname):
project = project_no_dedicated_env(dirname)
environ = minimal_environ(BAR='bar')
result = prepare_without_interaction(project, environ=environ, command_name="blah")
assert not result
assert result.errors
assert "Command name 'blah' is not in" in result.errors[0]
def _commit_requirement_if_it_works(project, env_var_or_class, env_spec_name=None):
project.project_file.use_changes_without_saving()
# See if we can perform the download
result = prepare.prepare_without_interaction(project,
provide_whitelist=(CondaEnvRequirement,
env_var_or_class, ),
env_spec_name=env_spec_name)
status = result.status_for(env_var_or_class)
if status is None:
# I _think_ this is currently impossible, but if it were possible,
# we'd need to below code and it's hard to prove it's impossible.
status = project.problems_status() # pragma: no cover # no way to cause right now?
# caller was supposed to expect env_var_or_class to still exist,
# unless project file got mangled
assert status is not None # pragma: no cover
if not status:
# reload from disk, discarding our changes because they did not work
project.project_file.load()
else:
# yay!
project.project_file.save()
return status
def unprepare_empty(dirname):
project = project_no_dedicated_env(dirname)
environ = minimal_environ()
result = prepare_without_interaction(project, environ=environ)
assert result
status = unprepare(project, result)
assert status
def _prepare_printing_errors(project,
environ=None,
mode=provide.PROVIDE_MODE_DEVELOPMENT):
result = prepare_without_interaction(project, environ=environ, mode=mode)
if result.failed:
result.print_output()
return result
def check(dirname):
project = project_no_dedicated_env(dirname)
environ = minimal_environ(BAR='bar')
result = prepare_without_interaction(project, environ=environ, command_name="blah")
assert not result
assert result.errors
assert "Command name 'blah' is not in" in result.errors[0]
def provide_download(dirname):
@gen.coroutine
def mock_downloader_run(self, loop):
class Res:
pass
res = Res()
res.code = 200
with open(os.path.join(dirname, 'data.csv'), 'w') as out:
out.write('data')
self._hash = '12345abcdef'
raise gen.Return(res)
monkeypatch.setattr("conda_kapsel.internal.http_client.FileDownloader.run", mock_downloader_run)
project = project_no_dedicated_env(dirname)
result = prepare_without_interaction(project, environ=minimal_environ(PROJECT_DIR=dirname))
assert hasattr(result, 'environ')
assert 'DATAFILE' in result.environ
filename = os.path.join(dirname, 'data.csv')
assert os.path.exists(filename)
def mock_remove(path):
raise IOError("Not gonna remove this")
monkeypatch.setattr("os.remove", mock_remove)
status = unprepare(project, result)
assert status.logs == []
assert status.status_description == ('Failed to remove %s: Not gonna remove this.' % filename)
assert status.errors == []
assert not status
assert os.path.exists(filename)
monkeypatch.undo() # so os.remove isn't broken during directory cleanup
def prepare_project_locally(self,
project,
environ,
env_spec_name=None,
command_name=None,
command=None,
extra_command_args=None):
"""Prepare a project to run one of its commands.
"Locally" means a machine where development will go on,
contrasted with say a production deployment.
This method takes any needed actions such as creating
environments or starting services, without asking the user
for permission.
This method returns a result object. The result object has
a ``failed`` property. If the result is failed, the
``errors`` property has the errors. If the result is not
failed, the ``command_exec_info`` property has the stuff
you need to run the project's default command, and the
``environ`` property has the updated environment. The
passed-in ``environ`` is not modified in-place.
You can update your original environment with
``result.update_environ()`` if you like, but it's probably
a bad idea to modify ``os.environ`` in that way because
the calling app won't want to have the project
environment.
The ``environ`` should usually be kept between
preparations, starting out as ``os.environ`` but then
being modified by the user.
If the project has a non-empty ``problems`` attribute,
this function returns the project problems inside a failed
result. So ``project.problems`` does not need to be checked in
advance.
Args:
project (Project): from the ``load_project`` method
environ (dict): os.environ or the previously-prepared environ; not modified in-place
env_spec_name (str): the package set name to require, or None for default
command_name (str): which named command to choose from the project, None for default
command (ProjectCommand): a command object (alternative to command_name)
extra_command_args (list): extra args to include in the returned command argv
Returns:
a ``PrepareResult`` instance, which has a ``failed`` flag
"""
return prepare.prepare_without_interaction(
project=project,
environ=environ,
mode=provide.PROVIDE_MODE_DEVELOPMENT,
env_spec_name=env_spec_name,
command_name=command_name,
command=command,
extra_command_args=extra_command_args)
def prepare_empty(dirname):
project = project_no_dedicated_env(dirname)
environ = minimal_environ()
result = prepare_without_interaction(project, environ=environ)
assert result
assert dict(PROJECT_DIR=project.directory_path) == strip_environ(result.environ)
assert dict() == strip_environ(environ)
assert result.command_exec_info is None
def unprepare_nothing(dirname):
project = project_no_dedicated_env(dirname)
environ = minimal_environ()
result = prepare_without_interaction(project, environ=environ)
assert result
status = unprepare(project, result, whitelist=[])
assert status
assert status.status_description == 'Nothing to clean up.'
def prepare_empty(dirname):
project = project_no_dedicated_env(dirname)
environ = minimal_environ()
result = prepare_without_interaction(project, environ=environ)
assert result
assert dict(PROJECT_DIR=project.directory_path) == strip_environ(result.environ)
assert dict() == strip_environ(environ)
assert result.command_exec_info is None
def unprepare_nothing(dirname):
project = project_no_dedicated_env(dirname)
environ = minimal_environ()
result = prepare_without_interaction(project, environ=environ)
assert result
status = unprepare(project, result, whitelist=[])
assert status
assert status.status_description == 'Nothing to clean up.'
def prepare_then_update_environ(dirname):
project = project_no_dedicated_env(dirname)
environ = minimal_environ(FOO='bar')
result = prepare_without_interaction(project, environ=environ)
assert result
other = minimal_environ(BAR='baz')
result.update_environ(other)
assert dict(FOO='bar', BAR='baz', PROJECT_DIR=dirname) == strip_environ(other)
def prepare_then_update_environ(dirname):
project = project_no_dedicated_env(dirname)
environ = minimal_environ(FOO='bar')
result = prepare_without_interaction(project, environ=environ)
assert result
other = minimal_environ(BAR='baz')
result.update_environ(other)
assert dict(FOO='bar', BAR='baz', PROJECT_DIR=dirname) == strip_environ(other)
def check_env_var_provider_prepare(dirname):
project = project_no_dedicated_env(dirname)
result = prepare_without_interaction(project, environ=minimal_environ(FOO='bar'))
assert result
status = unprepare(project, result)
assert status
assert status.status_description == 'Success.'
assert status.logs == ["Nothing to clean up for FOO.",
("Current environment is not in %s, no need to delete it." % dirname)]
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
expected_path = project.env_specs['bar'].path(project.directory_path)
assert result.environ[env_var] == expected_path
finally:
_pop_fake_env_creator()
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
expected_path = project.env_specs['bar'].path(project.directory_path)
assert result.environ[env_var] == expected_path
finally:
_pop_fake_env_creator()
def check(dirname):
# create a command that isn't in the Project
project = project_no_dedicated_env(dirname)
command = ProjectCommand(name="foo",
attributes=dict(bokeh_app="foo.py",
env_spec=project.default_env_spec_name))
environ = minimal_environ()
result = prepare_without_interaction(project, environ=environ, command=command)
assert result
assert result.command_exec_info.bokeh_app == 'foo.py'
def check(dirname):
# create a command that isn't in the Project
project = project_no_dedicated_env(dirname)
command = ProjectCommand(name="foo",
attributes=dict(bokeh_app="foo.py",
env_spec=project.default_env_spec_name))
environ = minimal_environ()
result = prepare_without_interaction(project, environ=environ, command=command)
assert result
assert os.path.join(project.directory_path, 'foo.py') in result.command_exec_info.args
def unprepare_problems(dirname):
project = project_no_dedicated_env(dirname)
environ = minimal_environ()
result = prepare_without_interaction(project, environ=environ)
assert not result
status = unprepare(project, result)
assert not status
assert status.status_description == 'Unable to load the project.'
assert status.errors == ['variables section contains wrong value type 42, ' +
'should be dict or list of requirements']
def unprepare_problems(dirname):
project = project_no_dedicated_env(dirname)
environ = minimal_environ()
result = prepare_without_interaction(project, environ=environ)
assert not result
status = unprepare(project, result)
assert not status
assert status.status_description == 'Unable to load the project.'
assert status.errors == ['variables section contains wrong value type 42, ' +
'should be dict or list of requirements']
def prepare_project_scoped_env(dirname):
project = Project(dirname)
fake_old_path = "foo" + os.pathsep + "bar"
environ = dict(PROJECT_DIR=dirname, PATH=fake_old_path)
result = prepare_without_interaction(project, environ=environ)
assert result
expected_env = os.path.join(dirname, "envs", "default")
if platform.system() == 'Windows':
expected_new_path = expected_env + os.pathsep + os.path.join(
expected_env, script_dir) + os.pathsep + os.path.join(expected_env, "Library",
"bin") + os.pathsep + "foo" + os.pathsep + "bar"
else:
expected_new_path = os.path.join(expected_env, script_dir) + os.pathsep + "foo" + os.pathsep + "bar"
expected = dict(PROJECT_DIR=project.directory_path, PATH=expected_new_path)
conda_api.environ_set_prefix(expected, expected_env)
expected == result.environ
assert os.path.exists(os.path.join(expected_env, "conda-meta"))
conda_meta_mtime = os.path.getmtime(os.path.join(expected_env, "conda-meta"))
# bare minimum default env shouldn't include these
# (contrast with the test later where we list them in
# requirements)
installed = conda_api.installed(expected_env)
assert 'ipython' not in installed
assert 'numpy' not in installed
# Prepare it again should no-op (use the already-existing environment)
environ = dict(PROJECT_DIR=dirname, PATH=fake_old_path)
result = prepare_without_interaction(project, environ=environ)
assert result
expected = dict(PROJECT_DIR=project.directory_path, PATH=expected_new_path)
conda_api.environ_set_prefix(expected, expected_env)
assert expected == result.environ
assert conda_meta_mtime == os.path.getmtime(os.path.join(expected_env, "conda-meta"))
# Now unprepare
status = unprepare(project, result)
assert status
assert status.status_description == ('Deleted environment files in %s.' % (expected_env))
assert status.errors == []
assert not os.path.exists(expected_env)
def remove_service(project_dir, variable_name):
"""Remove an item from the services section."""
project = load_project(project_dir)
result = prepare_without_interaction(project, mode=PROVIDE_MODE_CHECK)
status = project_ops.remove_service(project, result, variable_name=variable_name)
if status:
print(status.status_description)
return 0
else:
console_utils.print_status_errors(status)
return 1
def provide_download(dirname):
@gen.coroutine
def mock_downloader_run(self, loop):
raise Exception("should not have tried to download in check mode")
monkeypatch.setattr("conda_kapsel.internal.http_client.FileDownloader.run", mock_downloader_run)
project = project_no_dedicated_env(dirname)
result = prepare_without_interaction(project,
environ=minimal_environ(PROJECT_DIR=dirname),
mode=provide.PROVIDE_MODE_CHECK)
assert not result
def remove_download(project_dir, filename_variable):
"""Remove a download requirement from project and from file system."""
project = load_project(project_dir)
result = prepare_without_interaction(project, mode=PROVIDE_MODE_CHECK)
status = project_ops.remove_download(project, result, env_var=filename_variable)
if status:
print(status.status_description)
print("Removed {} from the project file.".format(filename_variable))
return 0
else:
console_utils.print_status_errors(status)
return 1
def provide_download(dirname):
FILENAME = os.path.join(dirname, 'data.csv')
requirement = _download_requirement()
local_state_file = LocalStateFile.load_for_directory(dirname)
local_state_file.set_service_run_state(requirement.env_var, {'filename': FILENAME})
local_state_file.save()
with open(FILENAME, 'w') as out:
out.write('data')
project = project_no_dedicated_env(dirname)
result = prepare_without_interaction(project, environ=minimal_environ(PROJECT_DIR=dirname))
assert hasattr(result, 'environ')
assert 'DATAFILE' in result.environ
def prepare_project_scoped_env_with_packages(dirname):
project = Project(dirname)
environ = minimal_environ(PROJECT_DIR=dirname)
result = prepare_without_interaction(project, environ=environ)
assert result
prefix = result.environ[conda_env_var]
installed = conda_api.installed(prefix)
assert 'ipython' in installed
assert 'numpy' in installed
assert 'bokeh' not in installed
# Preparing it again with new packages added should add those
deps = project.project_file.get_value('packages')
project.project_file.set_value('packages', deps + ['bokeh'])
project.project_file.save()
environ = minimal_environ(PROJECT_DIR=dirname)
result = prepare_without_interaction(project, environ=environ)
result.print_output()
assert result
prefix = result.environ[conda_env_var]
installed = conda_api.installed(prefix)
assert 'ipython' in installed
assert 'numpy' in installed
assert 'bokeh' in installed
installed_pip = pip_api.installed(prefix)
assert 'flake8' in installed_pip
# Preparing it again with a bogus package should fail
deps = project.project_file.get_value('packages')
project.project_file.set_value(['packages'], deps + ['boguspackage'])
project.project_file.save()
environ = minimal_environ(PROJECT_DIR=dirname)
result = prepare_without_interaction(project, environ=environ)
assert not result
def remove_service(project_dir, variable_name):
"""Remove an item from the services section."""
project = load_project(project_dir)
result = prepare_without_interaction(project, mode=PROVIDE_MODE_CHECK)
status = project_ops.remove_service(project,
result,
variable_name=variable_name)
if status:
print(status.status_description)
return 0
else:
console_utils.print_status_errors(status)
return 1
def provide_download(dirname):
@gen.coroutine
def mock_downloader_run(self, loop):
# if we don't even get an HTTP response, the errors are handled this way,
# e.g. if the URL is bad.
self._errors = ['This went horribly wrong']
raise gen.Return(None)
monkeypatch.setattr("conda_kapsel.internal.http_client.FileDownloader.run", mock_downloader_run)
project = project_no_dedicated_env(dirname)
result = prepare_without_interaction(project, environ=minimal_environ(PROJECT_DIR=dirname))
assert not result
assert ('missing requirement to run this project: A downloaded file which is referenced by DATAFILE.'
) in result.errors
def prepare_project_scoped_env_fails(dirname):
project = Project(dirname)
environ = minimal_environ(PROJECT_DIR=dirname)
result = prepare_without_interaction(project, environ=environ)
assert not result
assert 'CONDA_DEFAULT_ENV' not in result.environ
assert 'CONDA_ENV_PATH' not in result.environ
# unprepare should not have anything to do
status = unprepare(project, result)
assert status
assert status.errors == []
assert status.status_description == "Nothing to clean up for environment 'default'."
def clean_command(project_dir):
"""Clean up generated state.
Returns:
exit code
"""
project = load_project(project_dir)
result = prepare_without_interaction(project, mode=PROVIDE_MODE_CHECK)
status = project_ops.clean(project, result)
if status:
print(status.status_description)
return 0
else:
console_utils.print_status_errors(status)
return 1
def _prepare_env_prefix(project, env_spec_name):
failed = project.problems_status()
if failed is not None:
return (None, failed)
# we need an env prefix to store in keyring
result = prepare.prepare_without_interaction(project,
provide_whitelist=(CondaEnvRequirement, ),
env_spec_name=env_spec_name)
status = result.status_for(CondaEnvRequirement)
assert status is not None
if not status:
return (None, status)
else:
return (result.environ[status.requirement.env_var], status)
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 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 provide_download(dirname):
@gen.coroutine
def mock_downloader_run(self, loop):
class Res:
pass
res = Res()
res.code = 400
raise gen.Return(res)
monkeypatch.setattr("conda_kapsel.internal.http_client.FileDownloader.run", mock_downloader_run)
project = project_no_dedicated_env(dirname)
result = prepare_without_interaction(project, environ=minimal_environ(PROJECT_DIR=dirname))
assert not result
assert ('missing requirement to run this project: A downloaded file which is referenced by DATAFILE.'
) in result.errors
def _prepare_env_prefix(project, env_spec_name):
failed = project.problems_status()
if failed is not None:
return (None, failed)
# we need an env prefix to store in keyring
result = prepare.prepare_without_interaction(
project,
provide_whitelist=(CondaEnvRequirement, ),
env_spec_name=env_spec_name)
status = result.status_for(CondaEnvRequirement)
assert status is not None
if not status:
return (None, status)
else:
return (result.environ[status.requirement.env_var], status)
def provide_download(dirname):
@gen.coroutine
def mock_downloader_run(self, loop):
class Res:
pass
res = Res()
res.code = 200
with open(os.path.join(dirname, 'data.csv'), 'w') as out:
out.write('data')
raise gen.Return(res)
monkeypatch.setattr("conda_kapsel.internal.http_client.FileDownloader.run", mock_downloader_run)
project = project_no_dedicated_env(dirname)
result = prepare_without_interaction(project, environ=minimal_environ(PROJECT_DIR=dirname))
assert hasattr(result, 'environ')
assert 'DATAFILE' in result.environ
def prepare_project_production(self,
project,
environ,
env_spec_name=None,
command_name=None,
command=None,
extra_command_args=None):
"""Prepare a project to run one of its commands.
"Production" means some sort of production deployment, so
services have to be 'real' and not some kind of
local/temporary throwaway. We won't just start things up
willy-nilly.
We still do some things automatically in production
though, such as creating environments.
This method does not interact with the user; it "does the
right thing" without asking.
See ``prepare_project_locally()`` for additional details
that also apply to this method.
Args:
project (Project): from the ``load_project`` method
environ (dict): os.environ or the previously-prepared environ; not modified in-place
env_spec_name (str): the package set name to require, or None for default
command_name (str): which named command to choose from the project, None for default
command (ProjectCommand): a command object (alternative to command_name)
extra_command_args (list): extra args to include in the returned command argv
Returns:
a ``PrepareResult`` instance, which has a ``failed`` flag
"""
return prepare.prepare_without_interaction(
project=project,
environ=environ,
mode=provide.PROVIDE_MODE_PRODUCTION,
env_spec_name=env_spec_name,
command_name=command_name,
command=command,
extra_command_args=extra_command_args)
def prepare_system_environ(dirname):
project = project_no_dedicated_env(dirname)
os_environ_copy = deepcopy(os.environ)
result = prepare_without_interaction(project)
assert project.directory_path == strip_environ(result.environ)['PROJECT_DIR']
# os.environ wasn't modified
assert os_environ_copy == os.environ
# result.environ inherits everything in os.environ
for key in os_environ_copy:
if key == 'PATH' and platform.system() == 'Windows' and result.environ[key] != os.environ[key]:
print("prepare changed PATH on Windows and ideally it would not.")
else:
if key == 'PATH' and result.environ[key] != os.environ[key]:
original = os.environ[key].split(os.pathsep)
updated = result.environ[key].split(os.pathsep)
print("ORIGINAL PATH: " + repr(original))
print("UPDATED PATH: " + repr(updated))
assert original == updated
assert result.environ.get(key) == os.environ.get(key)
def prepare_with_app_entry(dirname):
project = project_no_dedicated_env(dirname)
environ = minimal_environ(FOO='bar')
env_path = conda_api.environ_get_prefix(environ)
result = prepare_without_interaction(project, environ=environ)
assert result
command = result.command_exec_info
assert 'FOO' in command.env
assert command.cwd == project.directory_path
if platform.system() == 'Windows':
commandpath = os.path.join(env_path, "python.exe")
else:
commandpath = os.path.join(env_path, "bin", "python")
assert command.args == [commandpath, 'echo.py', env_path, 'foo', 'bar']
p = command.popen(stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(out, err) = p.communicate()
# strip is to pull off the platform-specific newline
assert out.decode().strip() == ("['echo.py', '%s', 'foo', 'bar']" % (env_path.replace("\\", "\\\\")))
assert err.decode() == ""
def _commit_requirement_if_it_works(project,
env_var_or_class,
env_spec_name=None):
project.project_file.use_changes_without_saving()
# See if we can perform the download
result = prepare.prepare_without_interaction(project,
provide_whitelist=(
CondaEnvRequirement,
env_var_or_class,
),
env_spec_name=env_spec_name)
status = result.status_for(env_var_or_class)
if status is None or not status:
# reload from disk, discarding our changes because they did not work
project.project_file.load()
else:
# yay!
project.project_file.save()
return status
def prepare_project_check(self,
project,
environ,
env_spec_name=None,
command_name=None,
command=None,
extra_command_args=None):
"""Prepare a project to run one of its commands.
This version only checks the status of the project's
requirements, but doesn't take any actions; it won't
create files or start processes or anything like that. If
it returns a successful result, the project can be
prepared without taking any further action.
See ``prepare_project_locally()`` for additional details
that also apply to this method.
Args:
project (Project): from the ``load_project`` method
environ (dict): os.environ or the previously-prepared environ; not modified in-place
env_spec_name (str): the package set name to require, or None for default
command_name (str): which named command to choose from the project, None for default
command (ProjectCommand): a command object (alternative to command_name)
extra_command_args (list): extra args to include in the returned command argv
Returns:
a ``PrepareResult`` instance, which has a ``failed`` flag
"""
return prepare.prepare_without_interaction(
project=project,
environ=environ,
mode=provide.PROVIDE_MODE_CHECK,
env_spec_name=env_spec_name,
command_name=command_name,
command=command,
extra_command_args=extra_command_args)
def prepare_some_env_var(dirname):
project = project_no_dedicated_env(dirname)
environ = minimal_environ(BAR='bar')
result = prepare_without_interaction(project, environ=environ)
assert not result
assert dict(BAR='bar') == strip_environ(environ)
def prepare_with_ui_mode_printing_errors(
project,
environ=None,
ui_mode=UI_MODE_TEXT_ASSUME_YES_DEVELOPMENT,
env_spec_name=None,
command_name=None,
command=None,
extra_command_args=None):
"""Perform all steps needed to get a project ready to execute.
This may need to ask the user questions, may start services,
run scripts, load configuration, install packages... it can do
anything. Expect side effects.
Args:
project (Project): the project
environ (dict): the environment to prepare (None to use os.environ)
ui_mode (str): one of ``UI_MODE_BROWSER``, ``UI_MODE_TEXT_ASSUME_YES_DEVELOPMENT``,
``UI_MODE_TEXT_ASSUME_YES_PRODUCTION``, ``UI_MODE_TEXT_ASSUME_NO``
env_spec_name (str): the environment spec name to require, or None for default
command_name (str): command name to use or None for default
command (ProjectCommand): a command object or None
extra_command_args (list of str): extra args for the command we prepare
Returns:
a ``PrepareResult`` instance
"""
assert ui_mode in _all_ui_modes # the arg parser should have guaranteed this
if ui_mode == UI_MODE_BROWSER:
result = prepare.prepare_with_browser_ui(
project,
environ,
env_spec_name=env_spec_name,
command_name=command_name,
command=command,
extra_command_args=extra_command_args,
keep_going_until_success=True)
else:
ask = False
if ui_mode == UI_MODE_TEXT_ASSUME_YES_PRODUCTION:
provide_mode = PROVIDE_MODE_PRODUCTION
elif ui_mode == UI_MODE_TEXT_ASSUME_YES_DEVELOPMENT:
provide_mode = PROVIDE_MODE_DEVELOPMENT
elif ui_mode == UI_MODE_TEXT_ASSUME_NO:
provide_mode = PROVIDE_MODE_CHECK
elif ui_mode == UI_MODE_TEXT_DEVELOPMENT_DEFAULTS_OR_ASK:
provide_mode = PROVIDE_MODE_DEVELOPMENT
ask = True
assert ui_mode != UI_MODE_TEXT_ASK_QUESTIONS # Not implemented yet
environ = None
while True:
result = prepare.prepare_without_interaction(
project,
environ,
mode=provide_mode,
env_spec_name=env_spec_name,
command_name=command_name,
command=command,
extra_command_args=extra_command_args)
if result.failed:
result.print_output()
if ask and _interactively_fix_missing_variables(
project, result):
environ = result.environ
continue # re-prepare, building on our previous environ
# if we didn't continue, quit.
break
return result
