def solve_environment(environment: dict) -> typing.Tuple[list, list]:
"""
Using the Conda API, Solve an environment, get back all
of the dependencies.
returns a list of {"name": name, "requirement": requirement} values.
"""
prefix = environment.get("prefix", ".")
channels = environment["channels"]
specs = [
f"{spec['name']} {spec.get('requirement', '')}".rstrip()
for spec in environment["dependencies"]
]
bad_specs = []
try:
dependencies = Solver(prefix, channels,
specs_to_add=specs).solve_final_state()
except ResolvePackageNotFound as e:
ok_specs, bad_specs = rigidly_parse_error_message(e.message, specs)
dependencies = Solver(prefix, channels,
specs_to_add=ok_specs).solve_final_state()
return (
[{
"name": dep["name"],
"requirement": dep["version"]
} for dep in dependencies],
bad_specs,
)
def test_Solver_return_value_contract():
solver = Solver('/', (Channel('pkgs/main'),), specs_to_add=('openssl',))
solve_final_state_rv = solver.solve_final_state()
assert isiterable(solve_final_state_rv)
assert all(isinstance(pref, PackageRecord) for pref in solve_final_state_rv)
solve_for_diff_rv = solver.solve_for_diff()
assert len(solve_for_diff_rv) == 2
unlink_precs, link_precs = solve_for_diff_rv
assert isiterable(unlink_precs)
assert all(isinstance(pref, PackageRecord) for pref in unlink_precs)
assert isiterable(link_precs)
assert all(isinstance(pref, PackageRecord) for pref in link_precs)
solve_for_transaction_rv = solver.solve_for_transaction()
assert isinstance(solve_for_transaction_rv, UnlinkLinkTransaction)
def test_Solver_return_value_contract():
solver = Solver('/', (Channel('pkgs/main'),), specs_to_add=('openssl',))
solve_final_state_rv = solver.solve_final_state()
assert isiterable(solve_final_state_rv)
assert all(isinstance(pref, PackageRef) for pref in solve_final_state_rv)
solve_for_diff_rv = solver.solve_for_diff()
assert len(solve_for_diff_rv) == 2
unlink_precs, link_precs = solve_for_diff_rv
assert isiterable(unlink_precs)
assert all(isinstance(pref, PackageRef) for pref in unlink_precs)
assert isiterable(link_precs)
assert all(isinstance(pref, PackageRef) for pref in link_precs)
solve_for_transaction_rv = solver.solve_for_transaction()
assert isinstance(solve_for_transaction_rv, UnlinkLinkTransaction)
def install_package(
versioned_package: str,
env_dir: pathlib.Path,
out_dir: pathlib.Path,
verbose: bool = True,
exit: bool = False,
):
"""
Installs a package into an isolated environment
:param versioned_package:
:param env_dir:
:param out_dir:
:param verbose:
:param exit:
:return:
"""
# Create an empty environment
run_command(
"create", "--yes", "--quiet", "--prefix", env_dir,
)
with activate_env(pathlib.Path(env_dir)):
# Generate the query plan concurrently
solver = Solver(
str(env_dir),
["bioconda", "conda-forge", "r", "main", "free"],
specs_to_add=[versioned_package],
)
try:
transaction = solver.solve_for_transaction()
except Exception as e:
handle_exception(
e,
msg="Installing the package {}".format(versioned_package),
log_path=(out_dir / versioned_package).with_suffix(".error.txt"),
print=verbose,
exit=exit,
)
return
# We can't run the installs concurrently, because they used the shared conda packages cache
with lock:
transaction.download_and_extract()
transaction.execute()
def install(self, prefix):
specs = [
pkg.to_matchspec() for pkg in self.envionrment_model.conda_packages
]
if len(specs) > 0:
solver = Solver(prefix,
self.envionrment_model.config.channels,
subdirs=self.envionrment_model.config.subdirs,
specs_to_add=specs)
unlink_link_transaction = solver.solve_for_transaction()
TransactionHandler(unlink_link_transaction).execute(
prefix, self.envionrment_model.conda_packages, True)
pip_pkgs = [
"%s==%s" % (pkg.name, pkg.version)
for pkg in self.envionrment_model.pip_packages
]
if len(pip_pkgs) > 0:
pip_args = ["install"] + pip_pkgs
pip_util.pip_subprocess(pip_args, prefix, None)
def package_info(channel: str, name: str, version: str) -> dict:
channel, name, version = unquote_params(channel, name, version)
# join the name and version together with equals if it's provided
spec = "==".join([name, version]) if version else name
# solve the spec for this package.
packages = Solver(".", [channel], specs_to_add=[spec]).solve_final_state()
# find the package passed in, it will be there, as Solver rasies if not found
first_package_record = [dep for dep in packages if dep.name == name][0]
return dict(first_package_record.dump())
'openforcefields',
'smirnoff99Frosst',
'pyyaml',
'toml',
'bson',
'msgpack-python',
'xmltodict',
'qcelemental',
'qcportal',
'qcengine',
]
failed = []
succeeded = []
for dep in deps:
print(f"Trying dep {dep} ...")
solver = Solver(prefix='/Users/mwt/software/miniconda3/bin/python',
channels=['conda-forge', 'omnia', 'defaults'],
specs_to_add=[dep, 'python=3.8'])
try:
solver.solve_final_state()
succeeded.append(dep)
except UnsatisfiableError:
failed.append(dep)
print("The following packages are (probably) shipped with Python 3.8:")
print(succeeded)
print("The following packages are (probably) NOT shipped with Python 3.8:")
print(failed)