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