def test_info(): conda_info_out, conda_info_err, rc = run_command(Commands.INFO) assert_equals(conda_info_err, '') for name in ['platform', 'conda version', 'root environment', 'default environment', 'envs directories', 'package cache', 'channel URLs', 'config file', 'offline mode']: assert_in(name, conda_info_out) conda_info_e_out, conda_info_e_err, rc = run_command(Commands.INFO, '-e') assert_in('root', conda_info_e_out) assert_equals(conda_info_e_err, '') conda_info_s_out, conda_info_s_err, rc = run_command(Commands.INFO, '-s') assert_equals(conda_info_s_err, '') for name in ['sys.version', 'sys.prefix', 'sys.executable', 'conda location', 'conda-build', 'CIO_TEST', 'CONDA_DEFAULT_ENV', 'PATH', 'PYTHONPATH']: assert_in(name, conda_info_s_out) if config.platform == 'linux': assert_in('LD_LIBRARY_PATH', conda_info_s_out) if config.platform == 'osx': assert_in('DYLD_LIBRARY_PATH', conda_info_s_out) conda_info_all_out, conda_info_all_err, rc = run_command(Commands.INFO, '--all') assert_equals(conda_info_all_err, '') assert_in(conda_info_out, conda_info_all_out) assert_in(conda_info_e_out, conda_info_all_out) assert_in(conda_info_s_out, conda_info_all_out)
def test_info_root(): stdout, stderr, rc = run_command(Commands.INFO, "--root") assert rc == 0 assert not stderr assert isdir(stdout.strip()) stdout, stderr, rc = run_command(Commands.INFO, "--root", "--json") assert rc == 0 assert not stderr json_obj = json.loads(stdout.strip()) assert isdir(json_obj["root_prefix"])
def test_config_command_bad_args(): with make_temp_condarc() as rc: stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--add', 'notarealkey', 'test', use_exception_handler=True) assert stdout == '' stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--set', 'notarealkey', 'true', use_exception_handler=True) assert stdout == ''
def test_invalid_config(): condarc="""\ fgddgh channels: - test """ try: with make_temp_condarc(condarc) as rc: rc_path = rc run_command(Commands.CONFIG, '--file', rc, '--add', 'channels', 'test') except ConfigurationLoadError as err: assert "reason: invalid yaml at line" in err.message, err.message
def test_info_unsafe_channels(): url = "https://conda.anaconda.org/t/tk-123/a/b/c" with env_var("CONDA_CHANNELS", url): stdout, stderr, rc = run_command(Commands.INFO, "--unsafe-channels") assert rc == 0 assert not stderr assert "tk-123" in stdout stdout, stderr, rc = run_command(Commands.INFO, "--unsafe-channels", "--json") assert rc == 0 assert not stderr json_obj = json.loads(stdout.strip()) assert url in json_obj["channels"]
def test_info_package_json(): out, err, rc = run_command(Commands.INFO, "--json", "itsdangerous=1.0.0=py37_0") out = json.loads(out) assert set(out.keys()) == {"itsdangerous=1.0.0=py37_0"} assert len(out["itsdangerous=1.0.0=py37_0"]) == 1 assert isinstance(out["itsdangerous=1.0.0=py37_0"], list) out, err, rc = run_command(Commands.INFO, "--json", "itsdangerous") out = json.loads(out) assert set(out.keys()) == {"itsdangerous"} assert len(out["itsdangerous"]) > 1 assert isinstance(out["itsdangerous"], list)
def test_help_through_python_api(): stdout, stderr, rc = run_command(Commands.HELP) assert rc == 0 assert not stderr assert "\n install" in stdout with pytest.raises(EnvironmentLocationNotFound): run_command(Commands.LIST, "-p", "not-a-real-path") stdout, stderr, rc = run_command(Commands.LIST, "-p", "not-a-real-path", use_exception_handler=True) assert rc == 1 assert "Not a conda environment" in stderr assert not stdout
def test_info_package_json(): out, err, rc = run_command(Commands.INFO, "--json", "numpy=1.11.0=py35_0") out = json.loads(out) assert set(out.keys()) == {"numpy=1.11.0=py35_0"} assert len(out["numpy=1.11.0=py35_0"]) == 1 assert isinstance(out["numpy=1.11.0=py35_0"], list) out, err, rc = run_command(Commands.INFO, "--json", "numpy") out = json.loads(out) assert set(out.keys()) == {"numpy"} assert len(out["numpy"]) > 1 assert isinstance(out["numpy"], list)
def test_invalid_config(): condarc="""\ fgddgh channels: - test """ try: with make_temp_condarc(condarc) as rc: rc_path = rc run_command(Commands.CONFIG, '--file', rc, '--add', 'channels', 'test') except LoadError as err: error1 = "Load Error: in " error2 = "on line 1, column 8. Invalid YAML" assert error1 in err.message assert error2 in err.message
def test_config_set(): # Test the config set command # Make sure it accepts only boolean values for boolean keys and any value for string keys with make_temp_condarc() as rc: stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--set', 'always_yes', 'yes') assert stdout == '' assert stderr == '' stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--set', 'always_yes', 'no') assert stdout == '' assert stderr == ''
def test_config_command_show(): # test alphabetical yaml output with make_temp_condarc() as rc: stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--show') output_keys = yaml_load(stdout).keys() assert stderr == '' assert sorted(output_keys) == [item for item in output_keys]
def get_conda_envs_from_python_api(): try: from conda.cli.python_api import run_command, Commands except (ImportError, OSError): return from json import loads c_stdout, c_stderr, return_code = run_command(Commands.INFO, "--json") json_conda_info = loads(c_stdout) return json_conda_info["envs"]
def test_get_info_dict(cli_install_mock): # This test patches conda.cli.install.install to throw an artificial exception. # What we're looking for here is the proper behavior for how error reports work with # collecting `conda info` in this situation. with env_var('CONDA_REPORT_ERRORS', 'false', reset_context): out, err, rc = run_command(Commands.CREATE, "-n blargblargblarg blarg --dry-run --json", use_exception_handler=True) assert cli_install_mock.call_count == 1 sys.stdout.write(out) sys.stderr.write(err) assert not err json_obj = json.loads(out) assert json_obj['conda_info']['conda_version'] out, err, rc = run_command(Commands.CREATE, "-n blargblargblarg blarg --dry-run", use_exception_handler=True) sys.stderr.write(out) sys.stderr.write(err) assert "conda info could not be constructed" not in err assert not out
def test_config_set(): # Test the config set command # Make sure it accepts only boolean values for boolean keys and any value for string keys with make_temp_condarc() as rc: stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--set', 'always_yes', 'yes') assert stdout == '' assert stderr == '' with open(rc) as fh: content = yaml_load(fh.read()) assert content['always_yes'] is True stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--set', 'always_yes', 'no') assert stdout == '' assert stderr == '' with open(rc) as fh: content = yaml_load(fh.read()) assert content['always_yes'] is False stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--set', 'proxy_servers.http', '1.2.3.4:5678') assert stdout == '' assert stderr == '' with open(rc) as fh: content = yaml_load(fh.read()) assert content['always_yes'] is False assert content['proxy_servers'] == {'http': '1.2.3.4:5678'} stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--set', 'ssl_verify', 'false') assert stdout == '' assert stderr == '' stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--get', 'ssl_verify') assert stdout.strip() == '--set ssl_verify False' assert stderr == ''
def test_set_rc_string(): # Test setting string keys in .condarc # We specifically test ssl_verify since it can be either a boolean or a string with make_temp_condarc() as rc: assert context.ssl_verify is True stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--set', 'ssl_verify', 'no') assert stdout == '' assert stderr == '' reset_context([rc]) assert context.ssl_verify is False with NamedTemporaryFile() as tf: stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--set', 'ssl_verify', tf.name) assert stdout == '' assert stderr == '' reset_context([rc]) assert context.ssl_verify == tf.name
def test_info(): conda_info_out, conda_info_err, rc = run_command(Commands.INFO) assert_equals(conda_info_err, '') for name in ['platform', 'conda version', 'envs directories', 'package cache', 'channel URLs', 'config file', 'offline mode']: assert_in(name, conda_info_out) conda_info_e_out, conda_info_e_err, rc = run_command(Commands.INFO, '-e') assert_in('base', conda_info_e_out) assert_equals(conda_info_e_err, '') conda_info_s_out, conda_info_s_err, rc = run_command(Commands.INFO, '-s') assert_equals(conda_info_s_err, '') for name in ['sys.version', 'sys.prefix', 'sys.executable', 'conda location', 'conda-build', 'PATH']: assert_in(name, conda_info_s_out) conda_info_all_out, conda_info_all_err, rc = run_command(Commands.INFO, '--all') assert_equals(conda_info_all_err, '') assert_in(conda_info_out, conda_info_all_out) assert_in(conda_info_e_out, conda_info_all_out) assert_in(conda_info_s_out, conda_info_all_out)
def test_config_command_remove_force(): # Finally, test --remove, --remove-key with make_temp_condarc() as rc: run_command(Commands.CONFIG, '--file', rc, '--add', 'channels', 'test') run_command(Commands.CONFIG, '--file', rc, '--set', 'always_yes', 'true') stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--remove', 'channels', 'test') assert stdout == stderr == '' assert yaml_load(_read_test_condarc(rc)) == {'channels': ['defaults'], 'always_yes': True} stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--remove', 'channels', 'test', use_exception_handler=True) assert stdout == '' assert "CondaKeyError: 'channels': 'test' is not in the 'channels' " \ "key of the config file" in stderr stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--remove', 'disallow', 'python', use_exception_handler=True) assert stdout == '' assert "CondaKeyError: 'disallow': key 'disallow' " \ "is not in the config file" in stderr stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--remove-key', 'always_yes') assert stdout == stderr == '' assert yaml_load(_read_test_condarc(rc)) == {'channels': ['defaults']} stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--remove-key', 'always_yes', use_exception_handler=True) assert stdout == '' assert "CondaKeyError: 'always_yes': key 'always_yes' " \ "is not in the config file" in stderr
def get_json(self, search_string): """ Function takes search_string variable and returns results from the bioconda channel in JSON format """ if run_command is None: raise Exception( f"Invalid search destination. {deps_error_message('conda')}") raw_out, err, exit_code = run_command('search', '-c', self.channel, search_string, use_exception_handler=True) if exit_code != 0: logging.info(f'Search failed with: {err}') return [] return [{ 'package': n.split()[0], 'version': n.split()[1], 'build': n.split()[2] } for n in raw_out.split('\n')[2:-1]]
def getCondaPackages(): """Get products and their versions from the conda environment. Returns ------- packages : `dict` Keys (type `str`) are product names; values (type `str`) are their versions. Notes ----- Returns empty result if a conda environment is not in use or can not be queried. """ try: import json from conda.cli.python_api import Commands, run_command except ImportError: return {} # Get the installed package list versions_json = run_command(Commands.LIST, "--json") packages = { pkg["name"]: pkg["version"] for pkg in json.loads(versions_json[0]) } # Try to work out the conda environment name and include it as a fake # package. The "obvious" way of running "conda info --json" does give # access to the active_prefix but takes about 2 seconds to run. # The equivalent to the code above would be: # info_json = run_command(Commands.INFO, "--json") # As a comporomise look for the env name in the path to the python # executable match = re.search(r"/envs/(.*?)/bin/", sys.executable) if match: packages["conda_env"] = match.group(1) return packages
def get_package_list(): """Get list of currently installed packages Runs 'conda list -e' to get the currently installed packages. Returns: bytes -- Output of 'conda list -e' """ try: import conda.cli.python_api as cli return cli.run_command('list', "-e")[0].encode('utf-8') except ModuleNotFoundError: import subprocess try: result = subprocess.run(['conda', 'list', '-e'], stdout=subprocess.PIPE) return result.stdout except FileNotFoundError: return None
def check_ldd(self, path: str, env: str): """Run ldd on executables and libraries in a path, and find uses of a system version of libraries containing the package name Args: path: The path to a directory of (or a single) executables or libraries env: The conda environment in which to run ldd """ # '|| exit 0' prevents ldd from failing due to non executables stdout, stderr, code = run_command(Commands.RUN, "-n", env, "ldd", path, "||", "exit", "0") log.debug(f"ldd stdout: '{stdout}', stderr: '{stderr}', code: {code}") for line in stdout.split("\n"): if re.search(".*/usr/lib/.*", line): if self.sub_packages(): for sub in self.sub_packages(): if re.search(f'.*{sub}.*', line): raise LibError(line) else: if re.search(f".*{self.name()}.*", line): raise LibError(line)
def test_get_boolean_value(): with make_temp_condarc(CONDARC_BASE) as rc: stdout, stderr, _ = run_command(Commands.CONFIG, '--file', rc, '--get', 'changeps1') assert stdout.strip() == "--set changeps1 False" assert stderr == ""
else: extra_requires = ['openexr>=1.3.0'] dependency_links = [ 'https://github.com/jamesbowman/openexrpython/tarball/master#egg=openexr-1.3.0' ] package_data = { "sh": ["libsh.cpython-" + version_string + "m-x86_64-linux-gnu.so"], "tools3d": ["libspharm.cpython-" + version_string + "m-x86_64-linux-gnu.so"] } conda_install_packages = [ 'numpy', 'scipy', 'imageio', 'tqdm', 'cffi', 'astropy', 'pandas', 'xarray', 'matplotlib' ] out = Conda.run_command("install", conda_install_packages) setup( name='skylibs', description= ('Tools to read, write, perform projections and handle LDR/HDR environment maps (IBL).' ), author='Bruno Marques, Original author: Yannick Hold', author_email='*****@*****.**', license="LGPLv3", url='https://github.com/bdorta/skylibs', version='0.5', packages=[ 'ezexr', 'envmap', 'hdrio', 'hdrtools', 'hdrtools/tonemapping', 'sh', 'skydb', 'tools3d' ],
def install_app(app_name): package_name = app_name + "-app" channels, _, _ = run_command("config", "--show", "channels", "--json") if "conda-forge" not in channels: run_command("config", "--add", "channels", "conda-forge") print("Warning: conda-forge channel added!") if app_name not in known_apps_with_app_package: print(f"Checking if package {package_name} exists...") try: result = run_command("search", package_name, "--json") except Exception: package_name = app_name try: result = run_command("search", package_name, "--json") except Exception: print("An exception occurred during the conda search. " "It maybe that the package does not exist") sys.exit(1) print(f"Package {package_name} found!") print("Running conda info... ", end="", flush=True) conda_data = get_conda_data() print("done") path_root = conda_data["root_prefix"] if conda_data["root_writable"]: if os.name == "nt": # quickfix: I wasn't able to permanently set the PATH on Windows path_bin = Path(path_root) / "condabin" else: path_bin = Path(path_root) / "condabin/app" else: if not os.name == "nt": path_bin = Path.home() / ".local/bin/conda-app" else: print("\nError: conda-app cannot be used on Windows when " "conda root is not writable. " "You can retry with miniconda installed " "only for you (not globally).") sys.exit(1) path_bin.mkdir(exist_ok=True, parents=True) export_path_posix = f"export PATH={path_bin}:$PATH\n" # bash modif_config_file(bash_config, export_path_posix) # zsh modif_config_file(Path.home() / ".zshrc", export_path_posix) # fish modif_config_file( Path.home() / ".config/fish/config.fish", f"set -gx PATH {path_bin} $PATH\n", ) env_names = get_env_names(conda_data) env_name = "_env_" + app_name env_path = Path(path_root) / "envs" / env_name if env_name not in env_names: print( f"Create conda environment {env_name} " f"with package {package_name}... ", end="", flush=True, ) result = run_command("create", "-n", env_name, package_name, "--json") try: data_create = json.loads(result[0]) except json.decoder.JSONDecodeError: print( "\nwarning: json.decoder.JSONDecodeError " "(`conda create --json` produces text that can't be loaded as json!)" ) prefix = None for line in result[0].split("\n"): if '"prefix":' in line: prefix = line.split('"prefix": "')[1].split('"')[0] break if prefix is None: raise else: prefix = data_create["prefix"] env_path = Path(prefix) print("done") if app_name == "mercurial": path_home_hgrc = Path.home() / ".hgrc" if not path_home_hgrc.exists(): print("Filling ~/.hgrc with reasonable default " "(edit to fill correct username and email address!)") with open(path_home_hgrc, "w") as file: file.write(default_hgrc) try: commands = commands_app[app_name] except KeyError: commands = [app_name] for command in commands: if os.name == "nt": with open(path_bin / (command + ".bat"), "w") as file: file.write("@echo off\n" f"call conda activate {env_name}\n" f"{command} %*\n" "call conda deactivate\n") else: path_command = env_path / "bin" / command path_symlink = path_bin / command if path_symlink.exists(): path_symlink.unlink() path_symlink.symlink_to(path_command) if os.name == "nt": txt = "T" else: txt = "Open a new terminal and t" print(f"{app_name} should now be installed in\n{env_path}\n" + txt + f"he command(s) {commands} should be available.") add_to_app_list(app_name) else: print(f"environment {env_name} already exists in \n{env_path}\n" f"To reinstall or update {app_name}, first uninstall it with:\n" f"conda-app uninstall {app_name}")
def get_conda_data(): result = run_command("info", "--json") return json.loads(result[0])
## Import required Libraries import conda.cli.python_api as Conda import sys import json from datetime import datetime import os packages = [] ## Preparing package names as raw json file with open('raw_list.json', 'w') as fp: temp = Conda.run_command(Conda.Commands.LIST, '--json') fp.write(temp[0]) ## Processing json file and extracting package names with open('raw_list.json') as fp: dic = json.load(fp) for names in dic: packages.append(names.get('name')) ## Starting package updation start_time = datetime.now() for package_name in packages: print('Updating Package ' + package_name) line_break = '\n---------------------------------------------\n' try: print(f'start time :{datetime.now()}') temp = Conda.run_command(Conda.Commands.UPDATE, package_name) if 'already installed' in temp[0]: with open('logs.txt', 'a') as fp: fp.write(package_name + ' Package already Installed ')
def test_config_command_basics(): # Test that creating the file adds the defaults channel with make_temp_condarc() as rc: stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--add', 'channels', 'test') assert stdout == stderr == '' assert _read_test_condarc(rc) == """\ channels: - test - defaults """ print(_read_test_condarc(rc)) print(_read_test_condarc(rc)) print(_read_test_condarc(rc)) with make_temp_condarc() as rc: # When defaults is explicitly given, it should not be added stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--add', 'channels', 'test', '--add', 'channels', 'defaults', use_exception_handler=True) assert stdout == '' assert stderr.strip() == "Warning: 'defaults' already in 'channels' list, moving to the top" assert _read_test_condarc(rc) == """\ channels: - defaults - test """ # Duplicate keys should not be added twice with make_temp_condarc() as rc: stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--add', 'channels', 'test') assert stdout == stderr == '' stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--add', 'channels', 'test', use_exception_handler=True) assert stdout == '' assert stderr.strip() == "Warning: 'test' already in 'channels' list, moving to the top" assert _read_test_condarc(rc) == """\ channels: - test - defaults """ # Test append with make_temp_condarc() as rc: stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--add', 'channels', 'test') assert stdout == stderr == '' stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--append', 'channels', 'test', use_exception_handler=True) assert stdout == '' assert stderr.strip() == "Warning: 'test' already in 'channels' list, moving to the bottom" assert _read_test_condarc(rc) == """\ channels: - defaults - test """ # Test duoble remove of defaults with make_temp_condarc() as rc: stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--remove', 'channels', 'defaults') assert stdout == stderr == '' stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--remove', 'channels', 'defaults', use_exception_handler=True) assert stdout == '' assert "CondaKeyError: 'channels': 'defaults' is not in the 'channels' " \ "key of the config file" in stderr # Test creating a new file with --set with make_temp_condarc() as rc: stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--set', 'always_yes', 'true') assert stdout == stderr == '' assert _read_test_condarc(rc) == """\
pkgs_dir = os.path.join(sys.prefix, 'pkgs') channel_map = { 'free': 'https://repo.anaconda.com/pkgs/free', 'main': 'https://repo.anaconda.com/pkgs/main', 'r': 'https://repo.anaconda.com/pkgs/r', 'conda-forge': 'https://conda.anaconda.org/conda-forge', 'bioconda': 'https://conda.anaconda.org/bioconda', } with env_vars({ "CONDA_PKGS_DIRS": os.path.join('repos', 'main', subdir), }): try: python_api.run_command("create", "-n", "fakeenv", "--download-only", "python", "mkl") except: pass if sys.platform != "win32": try: python_api.run_command("create", "-n", "fakeenv", "--download-only", "libopenblas") except: pass for chan, url in channel_map.items(): for _subdir in (subdir, 'noarch'): subdir_path = os.path.join('repos', chan, _subdir) if not os.path.exists(subdir_path): os.makedirs(subdir_path) for fn in ("repodata.json", "repodata.json.bz2"):
def check_remote_conda(pkg_name): """Search conda remote for all moose-libmesh package information.""" search_tuple = run_command(Commands.SEARCH, ['-f', pkg_name, '--json']) if search_tuple[2] > 0: return None return latest_remote_libmesh_version(search_tuple[0])
def build_conda_pack(base_path, tmp, hexrd_package_channel, hexrdgui_output_folder): # First build the hexrdgui package recipe_path = str(base_path / '..' / 'conda.recipe') config = Config() config.channel = ['cjh1', 'anaconda', 'conda-forge'] config.channel_urls = ['cjh1', 'anaconda', 'conda-forge'] if hexrdgui_output_folder is not None: config.output_folder = hexrdgui_output_folder if hexrd_package_channel is not None: config.channel.insert(0, 'hexrd-channel') config.channel_urls.insert(0, hexrd_package_channel) # Determine the latest hexrd version in the hexrd_package_channel # (release or pre-release), and force that hexrd version to be used. params = [ Conda.Commands.SEARCH, '--channel', hexrd_package_channel, '--json', 'hexrd', ] output = Conda.run_command(*params) results = json.loads(output[0]) hexrd_version = results['hexrd'][-1]['version'] config.variant['hexrd_version'] = hexrd_version config.CONDA_PY = '38' logger.info('Building hexrdgui conda package.') CondaBuild.build(recipe_path, config=config) logger.info('Creating new conda environment.') # Now create a new environment to install the package into env_prefix = str(tmp / package_env_name) channels = ['--channel', 'anaconda', '--channel', 'conda-forge'] # For the mac we need to use our own version of Python built with the # latest SDK. See https://github.com/HEXRD/hexrdgui/issues/505 for # more details. So we add the HEXRD channel that has our Python package. if platform.system() == 'Darwin': channels = ['--channel', 'HEXRD'] + channels Conda.run_command(Conda.Commands.CREATE, '--prefix', env_prefix, *channels, 'python=3.8.4') hexrdgui_output_folder_uri = Path( hexrdgui_output_folder).absolute().as_uri() logger.info('Installing hexrdgui into new environment.') # Install hexrdgui into new environment params = [ Conda.Commands.INSTALL, '--prefix', env_prefix, '--channel', hexrdgui_output_folder_uri, '--channel', hexrd_package_channel, '--channel', 'cjh1', '--channel', 'anaconda', '--channel', 'conda-forge', f'hexrd=={hexrd_version}', 'hexrdgui' ] Conda.run_command(*params) # Override the libgfortran so we get a version that is # build with a SDK that is acceptable to the notary! if platform.system() == 'Darwin': params = [ Conda.Commands.INSTALL, '--prefix', env_prefix, '--channel', 'conda-forge', 'libgfortran=4.0.0' ] Conda.run_command(*params) logger.info('Generating tar from environment using conda-pack.') # Now use conda-pack to create relocatable archive archive_path = str(tmp / ('hexrdgui.%s' % archive_format)) CondaPack.pack(prefix=env_prefix, output=archive_path, format=archive_format) return archive_path
def test_get_map_subkey(key, value): with make_temp_condarc(CONDARC_MAPS) as rc: stdout, stderr, _ = run_command(Commands.CONFIG, '--file', rc, '--get', key) assert stdout.strip() == f"--set {key} {value}" assert stderr == ""
def build_parcel(): jinja_env = Environment(loader=FileSystemLoader('templates')) (jpy_version, parcel_version) = get_version() # Create the JupyterHub Environment render_environment_yaml(jinja_env, jpy_version=jpy_version) with open('environment.yml') as f: conda_env = yaml.load(f, Loader=yaml.Loader) check_call( 'conda env create --force -p {name}'.format(**conda_env).split(' ')) # Get the complete list of installed packages components = json.loads( run_command(Commands.LIST, '--json', '-p', conda_env['name'])[0]) jpy_version = [ x['version'] for x in components if x['name'] == conda_env['name'] ][0] # Create the meta folder under the conda-environment meta_dir = os.path.join(conda_env['name'], 'meta') os.makedirs(meta_dir, exist_ok=True) # Create the meta/parcel.json file parcel_template = jinja_env.get_template('parcel.yaml') parcel_rendered = parcel_template.render(conda_env=conda_env, jpy_version=jpy_version, parcel_version=parcel_version, components=components) parcel_dict = yaml.load(parcel_rendered, Loader=yaml.Loader) parcel_json = os.path.join(meta_dir, 'parcel.json') with open(parcel_json, 'w') as f: json.dump(parcel_dict, f) print(check_output(['validator.sh', '-p', parcel_json]).decode('utf-8')) # Create the scripts.defines file (a.k.a. activate script) shutil.copy('env.sh', os.path.join(meta_dir, parcel_dict['scripts']['defines'])) # Use conda-pack to create the .parcel file if os.path.exists('parcels'): shutil.rmtree('parcels') os.makedirs('parcels', exist_ok=True) parcel_fqn = '{name}-{version}'.format(**parcel_dict) parcel_file = conda_pack.pack(prefix=conda_env['name'], output='%s-distro.parcel' % parcel_fqn, arcroot=parcel_fqn, dest_prefix='/opt/cloudera/parcels/%s' % parcel_fqn, format="tar.gz", force=True) # Link generated file to selected distros distros = ['el6', 'el7'] for distro in distros: dest_name = 'parcels/{}-{}.parcel'.format(parcel_fqn, distro) os.symlink('../%s-distro.parcel' % parcel_fqn, dest_name) check_call(['validator.sh', '-f', dest_name]) # Generate the parcel manifest file print(check_output(['make_manifest.py', 'parcels']).decode('utf-8'))
def test_config_command_parser(): # Now test the YAML "parser" # Channels is normal content. # create_default_packages has extra spaces in list items condarc = """\ channels: - test - defaults create_default_packages : - ipython - numpy changeps1: false # Here is a comment always_yes: true """ # First verify that this itself is valid YAML assert yaml_load(condarc) == {'channels': ['test', 'defaults'], 'create_default_packages': ['ipython', 'numpy'], 'changeps1': False, 'always_yes': True} with make_temp_condarc(condarc) as rc: stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--get', use_exception_handler=True) print(stdout) assert stdout.strip() == """\ --set always_yes True --set changeps1 False --add channels 'defaults' # lowest priority --add channels 'test' # highest priority --add create_default_packages 'numpy' --add create_default_packages 'ipython'\ """ with open(rc, 'r') as fh: print(fh.read()) stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--prepend', 'channels', 'mychannel') assert stdout == stderr == '' with open(rc, 'r') as fh: print(fh.read()) assert _read_test_condarc(rc) == """\ channels: - mychannel - test - defaults create_default_packages: - ipython - numpy changeps1: false # Here is a comment always_yes: true """ stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--set', 'changeps1', 'true') assert stdout == stderr == '' assert _read_test_condarc(rc)== """\ channels: - mychannel - test - defaults create_default_packages: - ipython - numpy changeps1: true # Here is a comment always_yes: true """ # Test adding a new list key. We couldn't test this above because it # doesn't work yet with odd whitespace condarc = """\ channels: - test - defaults always_yes: true """ with make_temp_condarc(condarc) as rc: stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--add', 'disallowed_packages', 'perl') assert stdout == stderr == '' assert _read_test_condarc(rc) == condarc + """\
def test_config_command_get(): # Test --get condarc = """\ channels: - test - defaults create_default_packages: - ipython - numpy changeps1: false always_yes: true invalid_key: true channel_alias: http://alpha.conda.anaconda.org """ with make_temp_condarc(condarc) as rc: stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--get', use_exception_handler=True) assert stdout.strip() == """\ --set always_yes True --set changeps1 False --set channel_alias http://alpha.conda.anaconda.org --add channels 'defaults' # lowest priority --add channels 'test' # highest priority --add create_default_packages 'numpy' --add create_default_packages 'ipython'\ """ assert stderr.strip() == "unknown key invalid_key" stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--get', 'channels') assert stdout.strip() == """\ --add channels 'defaults' # lowest priority --add channels 'test' # highest priority\ """ assert stderr == "" stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--get', 'changeps1') assert stdout.strip() == """\ --set changeps1 False\ """ assert stderr == "" stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--get', 'changeps1', 'channels') assert stdout.strip() == """\ --set changeps1 False --add channels 'defaults' # lowest priority --add channels 'test' # highest priority\ """ assert stderr == "" stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--get', 'allow_softlinks') assert stdout == "" assert stderr == "" stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--get', 'always_softlink') assert stdout == "" assert stderr == "" stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--get', 'track_features') assert stdout == "" assert stderr == ""
import conda.cli.python_api as Conda import sys ################################################################################################### # The below is roughly equivalent to: # conda install -y 'args-go-here' 'no-whitespace-splitting-occurs' 'square-brackets-optional' (stdout_str, stderr_str, return_code_int) = Conda.run_command( Conda.Commands.INSTALL, # alternatively, you can just say "install" # ...it's probably safer long-term to use the Commands class though # Commands include: # CLEAN,CONFIG,CREATE,INFO,INSTALL,HELP,LIST,REMOVE,SEARCH,UPDATE,RUN [ 'args-go-here', 'no-whitespace-splitting-occurs', 'square-brackets-optional' ], use_exception_handler= True, # Defaults to False, use that if you want to handle your own exceptions stdout=sys.stdout, # Defaults to being returned as a str (stdout_str) stderr=sys.stderr, # Also defaults to being returned as str (stderr_str) search_path=Conda. SEARCH_PATH # this is the default; adding only for illustrative purposes ) ################################################################################################### #https://stackoverflow.com/questions/41767340/using-conda-install-within-a-python-script #import conda.cli #conda.cli.main('conda', 'install', '-y', 'numpy')
def show_about_dialog(self): # Initializes the message box. about_dialog = PyMod_QMessageBox(self.get_qt_parent()) about_dialog.setIcon(QtWidgets.QMessageBox.Information) about_dialog.setWindowTitle(self.pymod_plugin_name) # Sets the main text. about_dialog.setText("Version: %s" % self.pymod_version + "." + self.pymod_revision) infomative_text = ('Copyright (C): 2020 Giacomo Janson, Alessandro Paiardini\n' 'Copyright (C): 2016 Giacomo Janson, Chengxin Zhang, Alessandro Paiardini' '\n\nFor information on PyMod %s visit:\n' ' http://schubert.bio.uniroma1.it/pymod/\n\n' 'Or send us an email at:\n %s' % (self.pymod_version, self.developer_email)) about_dialog.setInformativeText(infomative_text) # Adds detailed information. pymod_plugin_path = os.path.dirname(os.path.dirname(pymod_lib.__file__)) try: import PyQt5 pyqt5_version = PyQt5.QtCore.PYQT_VERSION_STR except: pyqt5_version = "-" try: from pymol import Qt pymol_pyqt_name = Qt.PYQT_NAME except: pymol_pyqt_name = "-" try: import Bio biopython_version = Bio.__version__ except: biopython_version = "-" try: import numpy numpy_version = numpy.__version__ except: numpy_version = "-" try: import modeller modeller_version = modeller.__version__ modeller_path = repr(modeller.__path__) except: modeller_version = "-" modeller_path = "-" try: import conda import conda.cli.python_api as conda_api conda_version = conda.__version__ if self.DEVELOP: conda_info_dict = json.loads(conda_api.run_command(conda_api.Commands.INFO, "--json")[0]) conda_info_text = "\n# Conda\n" for k in sorted(conda_info_dict.keys()): conda_info_text += "- %s: %s\n" % (k, repr(conda_info_dict[k])) except: conda_version = "-" conda_info_dict = {} conda_info_text = "" has_pymol_conda = str(hasattr(pymol, "externing") and hasattr(pymol.externing, "conda")) def _get_path_string(path): _path = path if os.path.isdir(_path): return _path else: return _path + " (not found)" additional_text = ("# PyMod\n" "- Version: " + self.pymod_version + "\n" "- Revision: " + self.pymod_revision + "\n" "- Plugin path: " + _get_path_string(pymod_plugin_path) + " \n" "- Config directory: " + _get_path_string(self.cfg_directory_path) + "\n" "- PyMod Directory: " + _get_path_string(self.current_pymod_dirpath) + "\n" "- Current PyMod project: " + _get_path_string(self.current_project_dirpath) + "\n\n" "# PyMOL\n" "- Version: " + str(pymol.cmd.get_version()[0]) + "\n" "- Path: " + sys.executable + "\n" "- Qt: " + str(pymol_pyqt_name) + "\n" "- Has Conda: " + has_pymol_conda + "\n\n" "# Python\n" "- Version: " + str(sys.version) + "\n" "- Arch: " + pmos.get_python_architecture() + "\n" "- Path: " + sys.executable + "\n\n" "# Operating system\n" "- Platform: " + sys.platform + "\n" "- Arch: " + pmos.get_os_architecture() + "\n\n" "# Python libs\n" "- PyQt5: " + pyqt5_version + "\n" "- Conda version: " + conda_version + "\n" "- Numpy version: " + numpy_version + "\n" "- Biopython version: " + biopython_version + "\n" "- MODELLER version: " + modeller_version + "\n" "- MODELLER path: " + modeller_path + "\n" ) if self.DEVELOP: additional_text += conda_info_text about_dialog.setDetailedText(additional_text) # Actually shows the message box. about_dialog.setModal(True) about_dialog.exec_()
def test_config_command_get(): # Test --get condarc = """\ channels: - test - defaults create_default_packages: - ipython - numpy changeps1: false always_yes: true invalid_key: true channel_alias: http://alpha.conda.anaconda.org """ with make_temp_condarc(condarc) as rc: stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--get', use_exception_handler=True) assert stdout.strip() == """\ --set always_yes True --set changeps1 False --set channel_alias http://alpha.conda.anaconda.org --add channels 'defaults' # lowest priority --add channels 'test' # highest priority --add create_default_packages 'numpy' --add create_default_packages 'ipython'\ """ assert stderr.strip() == "unknown key invalid_key" stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--get', 'channels') assert stdout.strip() == """\ --add channels 'defaults' # lowest priority --add channels 'test' # highest priority\ """ assert stderr == "" stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--get', 'changeps1') assert stdout.strip() == """\ --set changeps1 False\ """ assert stderr == "" stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--get', 'changeps1', 'channels') assert stdout.strip() == """\ --set changeps1 False --add channels 'defaults' # lowest priority --add channels 'test' # highest priority\ """ assert stderr == "" stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--get', 'allow_softlinks') assert stdout == "" assert stderr == "" stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--get', 'always_softlink') assert stdout == "" assert stderr == "" stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--get', 'track_features') assert stdout == "" assert stderr == ""
def test_cli_args_as_list(): out, err, rc = run_command(Commands.CONFIG, ["--show", "add_anaconda_token"]) assert rc == 0
def test_get_unconfigured_key(): with make_temp_condarc(CONDARC_BASE) as rc: stdout, stderr, _ = run_command(Commands.CONFIG, '--file', rc, '--get', 'allow_softlinks') assert stdout == "" assert stderr == ""
def test_config_command_basics(): # Test that creating the file adds the defaults channel with make_temp_condarc() as rc: stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--add', 'channels', 'test') assert stdout == stderr == '' assert _read_test_condarc(rc) == """\ channels: - test - defaults """ print(_read_test_condarc(rc)) print(_read_test_condarc(rc)) print(_read_test_condarc(rc)) with make_temp_condarc() as rc: # When defaults is explicitly given, it should not be added stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--add', 'channels', 'test', '--add', 'channels', 'defaults', use_exception_handler=True) assert stdout == '' assert stderr.strip( ) == "Warning: 'defaults' already in 'channels' list, moving to the top" assert _read_test_condarc(rc) == """\ channels: - defaults - test """ # Duplicate keys should not be added twice with make_temp_condarc() as rc: stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--add', 'channels', 'test') assert stdout == stderr == '' stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--add', 'channels', 'test', use_exception_handler=True) assert stdout == '' assert stderr.strip( ) == "Warning: 'test' already in 'channels' list, moving to the top" assert _read_test_condarc(rc) == """\ channels: - test - defaults """ # Test append with make_temp_condarc() as rc: stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--add', 'channels', 'test') assert stdout == stderr == '' stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--append', 'channels', 'test', use_exception_handler=True) assert stdout == '' assert stderr.strip( ) == "Warning: 'test' already in 'channels' list, moving to the bottom" assert _read_test_condarc(rc) == """\ channels: - defaults - test """ # Test duoble remove of defaults with make_temp_condarc() as rc: stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--remove', 'channels', 'defaults') assert stdout == stderr == '' stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--remove', 'channels', 'defaults', use_exception_handler=True) assert stdout == '' assert "CondaKeyError: 'channels': 'defaults' is not in the 'channels' " \ "key of the config file" in stderr # Test creating a new file with --set with make_temp_condarc() as rc: stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--set', 'always_yes', 'true') assert stdout == stderr == '' assert _read_test_condarc(rc) == """\
def test_cli_args_as_strings(): out, err, rc = run_command(Commands.CONFIG, "--show", "add_anaconda_token") assert rc == 0
def test_config_command_parser(): # Now test the YAML "parser" # Channels is normal content. # create_default_packages has extra spaces in list items condarc = """\ channels: - test - defaults create_default_packages : - ipython - numpy changeps1: false # Here is a comment always_yes: true """ # First verify that this itself is valid YAML assert yaml_load(condarc) == { 'channels': ['test', 'defaults'], 'create_default_packages': ['ipython', 'numpy'], 'changeps1': False, 'always_yes': True } with make_temp_condarc(condarc) as rc: stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--get', use_exception_handler=True) print(stdout) assert stdout.strip() == """\ --set always_yes True --set changeps1 False --add channels 'defaults' # lowest priority --add channels 'test' # highest priority --add create_default_packages 'numpy' --add create_default_packages 'ipython'\ """ with open(rc, 'r') as fh: print(fh.read()) stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--prepend', 'channels', 'mychannel') assert stdout == stderr == '' with open(rc, 'r') as fh: print(fh.read()) assert _read_test_condarc(rc) == """\ channels: - mychannel - test - defaults create_default_packages: - ipython - numpy changeps1: false # Here is a comment always_yes: true """ stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--set', 'changeps1', 'true') assert stdout == stderr == '' assert _read_test_condarc(rc) == """\ channels: - mychannel - test - defaults create_default_packages: - ipython - numpy changeps1: true # Here is a comment always_yes: true """ # Test adding a new list key. We couldn't test this above because it # doesn't work yet with odd whitespace condarc = """\ channels: - test - defaults always_yes: true """ with make_temp_condarc(condarc) as rc: stdout, stderr, return_code = run_command(Commands.CONFIG, '--file', rc, '--add', 'disallow', 'perl') assert stdout == stderr == '' assert _read_test_condarc(rc) == condarc + """\
import os import cPickle import copy from cStringIO import StringIO if not hasattr(sys,'frozen'): RELATIVE_LIB_PATH = os.path.dirname(os.path.dirname(os.path.realpath(__file__))) sys.path.append(RELATIVE_LIB_PATH) else: RELATIVE_LIB_PATH = os.path.dirname(sys.eexecutable) import conda.cli.python_api as Conda #This grabs stuff from anaconda only! os.environ['PYTHONIOENCODING'] = 'UTF-8' x = Conda.run_command('list')[0].splitlines() yy = set(sorted(map(lambda xx:str(xx.split(' ')[0]),x))) #This is equivalent to running pip list import pkg_resources jj = set(sorted([p.project_name for p in pkg_resources.working_set])) #This is something that I don’t really understand.. uu = {i.split('.')[0] for i in sys.modules} stackpack = yy.union(jj.union(uu)) def updateSourceFile(fname): fname = os.path.realpath(fname) if os.path.splitext(fname)[1] == '.py': thedict = {'stack':[],